@composius/payload-plugin-import-wordpress 0.1.0

package/dist/index.js

@@ -0,0 +1,1832 @@
+// src/defaults.ts
+var authenticated = ({ req: { user } }) => Boolean(user);
+var defaultArticleUrl = (slug) => `${process.env.NEXT_PUBLIC_SERVER_URL || "http://localhost:3000"}/articles/${slug ?? ""}`;
+var JOBS_SLUG = "wp-import-jobs";
+var RECORDS_SLUG = "wp-import-records";
+var TASK_SLUG = "importWordpress";
+var resolveOptions = (pluginOptions) => ({
+  access: {
+    create: pluginOptions.access?.create ?? authenticated,
+    delete: pluginOptions.access?.delete ?? authenticated,
+    read: pluginOptions.access?.read ?? authenticated,
+    update: pluginOptions.access?.update ?? authenticated
+  },
+  articleUrl: pluginOptions.articleUrl ?? defaultArticleUrl,
+  authorMapping: {
+    strategy: pluginOptions.authorMapping?.strategy ?? "users",
+    defaultUserId: pluginOptions.authorMapping?.defaultUserId,
+    syntheticEmailDomain: pluginOptions.authorMapping?.syntheticEmailDomain ?? "imported.invalid"
+  },
+  collections: {
+    articles: pluginOptions.collections?.articles ?? "articles",
+    categories: pluginOptions.collections?.categories ?? "categories",
+    media: pluginOptions.collections?.media ?? "media",
+    authors: pluginOptions.collections?.authors ?? "authors",
+    users: pluginOptions.collections?.users ?? "users"
+  },
+  dryRunPageLimit: pluginOptions.dryRunPageLimit ?? 1,
+  excerptToSeoDescription: pluginOptions.excerptToSeoDescription ?? true,
+  firstImageAsCover: pluginOptions.firstImageAsCover ?? true,
+  fieldMap: {
+    title: pluginOptions.fieldMap?.title ?? "title",
+    slug: pluginOptions.fieldMap?.slug ?? "slug",
+    content: pluginOptions.fieldMap?.content ?? "content",
+    coverImage: pluginOptions.fieldMap?.coverImage ?? "coverImage",
+    category: pluginOptions.fieldMap?.category ?? "category",
+    publishedAt: pluginOptions.fieldMap?.publishedAt ?? "publishedAt"
+  },
+  redirects: pluginOptions.redirects ?? true,
+  request: {
+    concurrency: pluginOptions.request?.concurrency ?? 5,
+    timeoutMs: pluginOptions.request?.timeoutMs ?? 3e4,
+    userAgent: pluginOptions.request?.userAgent
+  }
+});
+
+// src/translations/en.ts
+var en = {
+  jobs: {
+    singular: "WordPress import",
+    plural: "WordPress imports",
+    tabs: {
+      configuration: "Configuration",
+      authors: "Authors",
+      categories: "Categories",
+      media: "Media",
+      posts: "Posts",
+      links: "Links & redirects",
+      report: "Report"
+    },
+    fields: {
+      sourceUrl: "WordPress site URL",
+      sourceUrlDescription: "Base URL of the WordPress site, e.g. https://example.com \u2014 its REST API (/wp-json) is read.",
+      credentials: "Credentials (optional)",
+      credentialsDescription: "Optional WordPress user + application password. When set, requests are authenticated so non-public data (e.g. author emails) can be imported.",
+      username: "Username",
+      applicationPassword: "Application password",
+      applicationPasswordDescription: "Create one in WordPress under Users \u2192 Profile \u2192 Application Passwords. Stored on this document \u2014 delete the job (or clear this field) after the import.",
+      dateFrom: "From date",
+      dateTo: "To date",
+      limit: "Max posts",
+      limitDescription: "Optional cap on the number of posts imported in this run.",
+      dryRun: "Dry run",
+      dryRunDescription: "Preview only: report what would be imported without writing anything. Limited to the first page(s).",
+      resume: "Resume / retry",
+      resumeDescription: "Re-queue this job to continue where it stopped (already-imported items are skipped).",
+      status: "Status",
+      progress: "Progress",
+      runs: "Run history",
+      authorsReport: "Imported authors",
+      categoriesReport: "Imported categories",
+      mediaReport: "Imported media",
+      postsReport: "Imported posts",
+      linksReport: "Link mapping",
+      errorsReport: "Errors",
+      startedAt: "Started at",
+      finishedAt: "Finished at"
+    },
+    status: {
+      queued: "Queued",
+      running: "Running",
+      paused: "Paused",
+      completed: "Completed",
+      failed: "Failed"
+    }
+  },
+  records: {
+    singular: "WordPress import record",
+    plural: "WordPress import records",
+    fields: {
+      job: "Import job",
+      site: "Site",
+      sourceType: "Source type",
+      sourceId: "Source ID",
+      sourceKey: "Source key",
+      targetCollection: "Target collection",
+      targetId: "Target ID",
+      status: "Status",
+      error: "Error"
+    }
+  }
+};
+
+// src/translations/fr.ts
+var fr = {
+  jobs: {
+    singular: "Import WordPress",
+    plural: "Imports WordPress",
+    tabs: {
+      configuration: "Configuration",
+      authors: "Auteurs",
+      categories: "Cat\xE9gories",
+      media: "M\xE9dias",
+      posts: "Articles",
+      links: "Liens et redirections",
+      report: "Rapport"
+    },
+    fields: {
+      sourceUrl: "URL du site WordPress",
+      sourceUrlDescription: "URL de base du site WordPress, ex. https://example.com \u2014 son API REST (/wp-json) est lue.",
+      credentials: "Identifiants (optionnel)",
+      credentialsDescription: "Utilisateur WordPress + mot de passe d\u2019application optionnels. Une fois d\xE9finis, les requ\xEAtes sont authentifi\xE9es pour importer des donn\xE9es non publiques (ex. e-mails des auteurs).",
+      username: "Nom d\u2019utilisateur",
+      applicationPassword: "Mot de passe d\u2019application",
+      applicationPasswordDescription: "\xC0 cr\xE9er dans WordPress sous Utilisateurs \u2192 Profil \u2192 Mots de passe d\u2019application. Stock\xE9 sur ce document \u2014 supprimez le travail (ou videz ce champ) apr\xE8s l\u2019import.",
+      dateFrom: "\xC0 partir du",
+      dateTo: "Jusqu'au",
+      limit: "Nombre max. d\u2019articles",
+      limitDescription: "Limite optionnelle du nombre d\u2019articles import\xE9s lors de cette ex\xE9cution.",
+      dryRun: "Simulation",
+      dryRunDescription: "Aper\xE7u uniquement : indique ce qui serait import\xE9 sans rien \xE9crire. Limit\xE9 \xE0 la ou les premi\xE8res pages.",
+      resume: "Reprendre / r\xE9essayer",
+      resumeDescription: "Remettre ce travail en file pour continuer l\xE0 o\xF9 il s\u2019est arr\xEAt\xE9 (les \xE9l\xE9ments d\xE9j\xE0 import\xE9s sont ignor\xE9s).",
+      status: "Statut",
+      progress: "Progression",
+      runs: "Historique des ex\xE9cutions",
+      authorsReport: "Auteurs import\xE9s",
+      categoriesReport: "Cat\xE9gories import\xE9es",
+      mediaReport: "M\xE9dias import\xE9s",
+      postsReport: "Articles import\xE9s",
+      linksReport: "Correspondance des liens",
+      errorsReport: "Erreurs",
+      startedAt: "D\xE9marr\xE9 \xE0",
+      finishedAt: "Termin\xE9 \xE0"
+    },
+    status: {
+      queued: "En file",
+      running: "En cours",
+      paused: "En pause",
+      completed: "Termin\xE9",
+      failed: "\xC9chou\xE9"
+    }
+  },
+  records: {
+    singular: "Enregistrement d\u2019import WordPress",
+    plural: "Enregistrements d\u2019import WordPress",
+    fields: {
+      job: "Travail d\u2019import",
+      site: "Site",
+      sourceType: "Type de source",
+      sourceId: "ID source",
+      sourceKey: "Cl\xE9 source",
+      targetCollection: "Collection cible",
+      targetId: "ID cible",
+      status: "Statut",
+      error: "Erreur"
+    }
+  }
+};
+
+// src/translations/index.ts
+var label = (pick) => ({
+  en: pick(en),
+  fr: pick(fr)
+});
+
+// src/collections/ImportJobs.ts
+var queueImport = async (req, jobId) => {
+  const queue = req.payload.jobs.queue;
+  await queue({ input: { jobId }, req, task: TASK_SLUG });
+};
+var ImportJobs = ({ access }) => ({
+  slug: "wp-import-jobs",
+  labels: {
+    singular: label((t) => t.jobs.singular),
+    plural: label((t) => t.jobs.plural)
+  },
+  admin: {
+    useAsTitle: "sourceUrl",
+    defaultColumns: ["sourceUrl", "status", "dryRun", "updatedAt"],
+    group: "WordPress import"
+  },
+  access: {
+    read: access.read,
+    create: access.create,
+    update: access.update,
+    delete: access.delete
+  },
+  hooks: {
+    afterChange: [
+      async ({ context, doc, operation, req }) => {
+        if (context?.wpImport) {
+          return doc;
+        }
+        if (operation === "create") {
+          await queueImport(req, doc.id);
+          return doc;
+        }
+        if (operation === "update" && doc.resume) {
+          await req.payload.update({
+            collection: "wp-import-jobs",
+            id: doc.id,
+            data: { resume: false, status: "queued" },
+            context: { wpImport: true },
+            req
+          });
+          await queueImport(req, doc.id);
+        }
+        return doc;
+      }
+    ]
+  },
+  fields: [
+    // Unnamed tabs keep their fields at the top level of the document data —
+    // one tab per import step, so each step's outcome reads in its own tab.
+    {
+      type: "tabs",
+      tabs: [
+        {
+          label: label((t) => t.jobs.tabs.configuration),
+          fields: [
+            {
+              name: "sourceUrl",
+              type: "text",
+              label: label((t) => t.jobs.fields.sourceUrl),
+              required: true,
+              admin: {
+                description: label((t) => t.jobs.fields.sourceUrlDescription)
+              }
+            },
+            {
+              name: "credentials",
+              type: "group",
+              label: label((t) => t.jobs.fields.credentials),
+              admin: {
+                description: label((t) => t.jobs.fields.credentialsDescription)
+              },
+              fields: [
+                {
+                  type: "row",
+                  fields: [
+                    {
+                      name: "username",
+                      type: "text",
+                      label: label((t) => t.jobs.fields.username),
+                      admin: { width: "50%" }
+                    },
+                    {
+                      name: "applicationPassword",
+                      type: "text",
+                      label: label((t) => t.jobs.fields.applicationPassword),
+                      admin: {
+                        width: "50%",
+                        description: label((t) => t.jobs.fields.applicationPasswordDescription),
+                        components: {
+                          // Masked (•••) input instead of plain text.
+                          Field: "@composius/payload-plugin-import-wordpress/client#ApplicationPasswordFieldClient"
+                        }
+                      }
+                    }
+                  ]
+                }
+              ]
+            },
+            {
+              type: "row",
+              fields: [
+                {
+                  name: "dateFrom",
+                  type: "date",
+                  label: label((t) => t.jobs.fields.dateFrom),
+                  admin: { width: "50%", date: { pickerAppearance: "dayOnly" } }
+                },
+                {
+                  name: "dateTo",
+                  type: "date",
+                  label: label((t) => t.jobs.fields.dateTo),
+                  admin: { width: "50%", date: { pickerAppearance: "dayOnly" } }
+                }
+              ]
+            },
+            {
+              name: "limit",
+              type: "number",
+              label: label((t) => t.jobs.fields.limit),
+              min: 1,
+              admin: {
+                description: label((t) => t.jobs.fields.limitDescription)
+              }
+            },
+            {
+              name: "dryRun",
+              type: "checkbox",
+              label: label((t) => t.jobs.fields.dryRun),
+              defaultValue: false,
+              admin: {
+                description: label((t) => t.jobs.fields.dryRunDescription)
+              }
+            },
+            {
+              name: "resume",
+              type: "checkbox",
+              label: label((t) => t.jobs.fields.resume),
+              defaultValue: false,
+              admin: {
+                description: label((t) => t.jobs.fields.resumeDescription)
+              }
+            }
+          ]
+        },
+        {
+          label: label((t) => t.jobs.tabs.authors),
+          fields: [
+            {
+              name: "authorsReport",
+              type: "json",
+              label: label((t) => t.jobs.fields.authorsReport),
+              admin: { readOnly: true }
+            }
+          ]
+        },
+        {
+          label: label((t) => t.jobs.tabs.categories),
+          fields: [
+            {
+              name: "categoriesReport",
+              type: "json",
+              label: label((t) => t.jobs.fields.categoriesReport),
+              admin: { readOnly: true }
+            }
+          ]
+        },
+        {
+          label: label((t) => t.jobs.tabs.media),
+          fields: [
+            {
+              name: "mediaReport",
+              type: "json",
+              label: label((t) => t.jobs.fields.mediaReport),
+              admin: { readOnly: true }
+            }
+          ]
+        },
+        {
+          label: label((t) => t.jobs.tabs.posts),
+          fields: [
+            {
+              name: "postsReport",
+              type: "json",
+              label: label((t) => t.jobs.fields.postsReport),
+              admin: { readOnly: true }
+            }
+          ]
+        },
+        {
+          label: label((t) => t.jobs.tabs.links),
+          fields: [
+            {
+              name: "linksReport",
+              type: "json",
+              label: label((t) => t.jobs.fields.linksReport),
+              admin: { readOnly: true }
+            }
+          ]
+        },
+        {
+          label: label((t) => t.jobs.tabs.report),
+          fields: [
+            {
+              name: "runs",
+              type: "json",
+              label: label((t) => t.jobs.fields.runs),
+              admin: { readOnly: true }
+            },
+            {
+              name: "progress",
+              type: "json",
+              label: label((t) => t.jobs.fields.progress),
+              admin: { readOnly: true }
+            },
+            {
+              name: "errorsReport",
+              type: "json",
+              label: label((t) => t.jobs.fields.errorsReport),
+              admin: { readOnly: true }
+            }
+          ]
+        }
+      ]
+    },
+    {
+      name: "status",
+      type: "select",
+      label: label((t) => t.jobs.fields.status),
+      defaultValue: "queued",
+      options: [
+        { label: label((t) => t.jobs.status.queued), value: "queued" },
+        { label: label((t) => t.jobs.status.running), value: "running" },
+        { label: label((t) => t.jobs.status.paused), value: "paused" },
+        { label: label((t) => t.jobs.status.completed), value: "completed" },
+        { label: label((t) => t.jobs.status.failed), value: "failed" }
+      ],
+      admin: {
+        position: "sidebar",
+        readOnly: true
+      }
+    },
+    {
+      name: "startedAt",
+      type: "date",
+      label: label((t) => t.jobs.fields.startedAt),
+      admin: { position: "sidebar", readOnly: true, date: { pickerAppearance: "dayAndTime" } }
+    },
+    {
+      name: "finishedAt",
+      type: "date",
+      label: label((t) => t.jobs.fields.finishedAt),
+      admin: { position: "sidebar", readOnly: true, date: { pickerAppearance: "dayAndTime" } }
+    }
+  ]
+});
+
+// src/collections/ImportRecords.ts
+var ImportRecords = ({ access }) => ({
+  slug: "wp-import-records",
+  labels: {
+    singular: label((t) => t.records.singular),
+    plural: label((t) => t.records.plural)
+  },
+  admin: {
+    useAsTitle: "sourceKey",
+    defaultColumns: ["site", "sourceType", "sourceId", "targetCollection", "targetId", "status"],
+    group: "WordPress import",
+    hidden: true
+  },
+  access: {
+    read: access.read,
+    create: access.create,
+    update: access.update,
+    delete: access.delete
+  },
+  indexes: [
+    { fields: ["site", "sourceType", "sourceId"] },
+    { fields: ["site", "sourceType", "sourceKey"] }
+  ],
+  fields: [
+    {
+      name: "job",
+      type: "relationship",
+      label: label((t) => t.records.fields.job),
+      relationTo: "wp-import-jobs"
+    },
+    {
+      name: "site",
+      type: "text",
+      label: label((t) => t.records.fields.site),
+      index: true,
+      required: true
+    },
+    {
+      name: "sourceType",
+      type: "select",
+      label: label((t) => t.records.fields.sourceType),
+      options: ["post", "category", "author", "media"],
+      index: true,
+      required: true
+    },
+    {
+      name: "sourceId",
+      type: "number",
+      label: label((t) => t.records.fields.sourceId),
+      index: true
+    },
+    {
+      name: "sourceKey",
+      type: "text",
+      label: label((t) => t.records.fields.sourceKey),
+      index: true
+    },
+    {
+      name: "targetCollection",
+      type: "text",
+      label: label((t) => t.records.fields.targetCollection)
+    },
+    {
+      name: "targetId",
+      type: "text",
+      label: label((t) => t.records.fields.targetId)
+    },
+    {
+      name: "status",
+      type: "select",
+      label: label((t) => t.records.fields.status),
+      defaultValue: "done",
+      options: ["done", "failed"]
+    },
+    {
+      name: "error",
+      type: "text",
+      label: label((t) => t.records.fields.error)
+    }
+  ]
+});
+
+// src/endpoints/index.ts
+import { APIError } from "payload";
+var assertAccess = async (access, operation, req) => {
+  const result = await access[operation]({ req });
+  if (!result) {
+    throw new APIError("Forbidden", 403);
+  }
+};
+var startEndpoint = (access) => ({
+  path: "/wp-import/start",
+  method: "post",
+  handler: async (req) => {
+    if (!req.user) {
+      throw new APIError("Unauthorized", 401);
+    }
+    await assertAccess(access, "create", req);
+    const body = await req.json?.() ?? {};
+    if (!body.sourceUrl) {
+      return Response.json({ error: "sourceUrl is required" }, { status: 400 });
+    }
+    const job = await req.payload.create({
+      collection: JOBS_SLUG,
+      data: {
+        dateFrom: body.dateFrom,
+        dateTo: body.dateTo,
+        dryRun: body.dryRun ?? false,
+        limit: body.limit,
+        sourceUrl: body.sourceUrl
+      },
+      overrideAccess: false,
+      req,
+      user: req.user
+    });
+    return Response.json({ jobId: job.id }, { status: 202 });
+  }
+});
+var statusEndpoint = (access) => ({
+  path: "/wp-import/status/:id",
+  method: "get",
+  handler: async (req) => {
+    if (!req.user) {
+      throw new APIError("Unauthorized", 401);
+    }
+    await assertAccess(access, "read", req);
+    const id = req.routeParams?.id;
+    const job = await req.payload.findByID({
+      collection: JOBS_SLUG,
+      id,
+      overrideAccess: false,
+      req,
+      user: req.user
+    });
+    return Response.json({
+      progress: job.progress,
+      report: {
+        authors: job.authorsReport,
+        categories: job.categoriesReport,
+        errors: job.errorsReport,
+        links: job.linksReport,
+        media: job.mediaReport,
+        posts: job.postsReport
+      },
+      runs: job.runs,
+      status: job.status
+    });
+  }
+});
+
+// src/lib/authors.ts
+import crypto from "crypto";
+
+// src/lib/id.ts
+var coerceId = (id) => typeof id === "number" ? id : /^\d+$/.test(id) ? Number(id) : id;
+
+// src/lib/url.ts
+var hostOf = (url) => {
+  try {
+    return new URL(url).host.toLowerCase();
+  } catch {
+    return null;
+  }
+};
+var pathOf = (url) => {
+  try {
+    return new URL(url).pathname || "/";
+  } catch {
+    const [pathAndQuery] = url.split("#");
+    const [path] = pathAndQuery.split("?");
+    return path.startsWith("/") ? path : `/${path}`;
+  }
+};
+var isInternalUrl = (url, siteHost) => {
+  if (!url) {
+    return false;
+  }
+  if (url.startsWith("#") || url.startsWith("mailto:") || url.startsWith("tel:")) {
+    return false;
+  }
+  const host = hostOf(url);
+  if (host === null) {
+    return true;
+  }
+  return host === siteHost.toLowerCase();
+};
+var permalinkToSlug = (url) => {
+  const path = pathOf(url).replace(/\/+$/, "");
+  if (!path || path === "") {
+    return null;
+  }
+  const segments = path.split("/").filter(Boolean);
+  const last = segments[segments.length - 1];
+  return last ? decodeURIComponent(last) : null;
+};
+var deriveOriginalImageUrl = (url) => {
+  const [beforeHash] = url.split("#");
+  const [path, query] = beforeHash.split("?");
+  const original = path.replace(/-\d+x\d+(\.[a-zA-Z0-9]+)$/, "$1");
+  return query ? `${original}?${query}` : original;
+};
+var filenameOf = (url) => {
+  const path = pathOf(url);
+  const base = path.split("/").filter(Boolean).pop() ?? "image";
+  return decodeURIComponent(base) || "image";
+};
+var NAMED_ENTITIES = {
+  agrave: "\xE0",
+  amp: "&",
+  apos: "'",
+  bdquo: "\u201E",
+  bull: "\u2022",
+  ccedil: "\xE7",
+  copy: "\xA9",
+  deg: "\xB0",
+  eacute: "\xE9",
+  ecirc: "\xEA",
+  egrave: "\xE8",
+  gt: ">",
+  hellip: "\u2026",
+  laquo: "\xAB",
+  ldquo: "\u201C",
+  lsaquo: "\u2039",
+  lsquo: "\u2018",
+  lt: "<",
+  mdash: "\u2014",
+  middot: "\xB7",
+  nbsp: " ",
+  ndash: "\u2013",
+  quot: '"',
+  raquo: "\xBB",
+  rdquo: "\u201D",
+  reg: "\xAE",
+  rsaquo: "\u203A",
+  rsquo: "\u2019",
+  sbquo: "\u201A",
+  trade: "\u2122"
+};
+var decodeEntities = (value) => value.replace(/&#x([0-9a-f]+);/gi, (_, hex) => String.fromCodePoint(parseInt(hex, 16))).replace(/&#(\d+);/g, (_, dec) => String.fromCodePoint(Number(dec))).replace(/&([a-zA-Z]+);/g, (match, name) => NAMED_ENTITIES[name.toLowerCase()] ?? match).trim();
+var stripHtml = (html) => decodeEntities(html.replace(/<[^>]*>/g, " ").replace(/\s+/g, " ")).trim();
+
+// src/lib/payloadOps.ts
+var createDoc = (payload, args) => payload.create({ overrideAccess: true, ...args });
+var findDocs = (payload, args) => payload.find({
+  overrideAccess: true,
+  ...args
+});
+var countDocs = (payload, args) => payload.count({
+  overrideAccess: true,
+  ...args
+});
+var findDoc = (payload, args) => payload.findByID({ overrideAccess: true, ...args });
+var updateDoc = (payload, args) => payload.update({ overrideAccess: true, ...args });
+
+// src/lib/records.ts
+var findDoneRecord = async (payload, lookup) => {
+  const where = lookup.sourceType === "media" && lookup.sourceKey ? {
+    and: [
+      { site: { equals: lookup.site } },
+      { sourceType: { equals: "media" } },
+      { sourceKey: { equals: lookup.sourceKey } },
+      { status: { equals: "done" } }
+    ]
+  } : {
+    and: [
+      { site: { equals: lookup.site } },
+      { sourceType: { equals: lookup.sourceType } },
+      { sourceId: { equals: lookup.sourceId } },
+      { status: { equals: "done" } }
+    ]
+  };
+  const { docs } = await findDocs(payload, {
+    collection: RECORDS_SLUG,
+    where,
+    limit: 1,
+    depth: 0
+  });
+  const doc = docs[0];
+  return doc?.targetId != null ? String(doc.targetId) : null;
+};
+var saveRecord = async (payload, args) => {
+  await createDoc(payload, {
+    collection: RECORDS_SLUG,
+    data: {
+      job: args.jobId,
+      site: args.site,
+      sourceType: args.sourceType,
+      sourceId: args.sourceId ?? void 0,
+      sourceKey: args.sourceKey ?? void 0,
+      targetCollection: args.targetCollection,
+      targetId: args.targetId != null ? String(args.targetId) : void 0,
+      status: args.status ?? "done",
+      error: args.error
+    }
+  });
+};
+
+// src/lib/media.ts
+var download = async (url, timeoutMs, fetchImpl) => {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const res = await fetchImpl(url, { signal: controller.signal });
+    if (!res.ok) {
+      throw new Error(`image download failed: ${res.status}`);
+    }
+    const arrayBuffer = await res.arrayBuffer();
+    const mimeType = res.headers.get("content-type")?.split(";")[0] || "image/jpeg";
+    return { buffer: Buffer.from(arrayBuffer), mimeType };
+  } finally {
+    clearTimeout(timer);
+  }
+};
+var importImage = async (payload, args) => {
+  const fetchImpl = args.fetchImpl ?? fetch;
+  const canonical = deriveOriginalImageUrl(args.url);
+  const cached = args.cache.get(canonical);
+  if (cached) {
+    return { ...cached, reused: true, uploaded: false };
+  }
+  const existing = await findDoneRecord(payload, {
+    site: args.site,
+    sourceKey: canonical,
+    sourceType: "media"
+  });
+  if (existing) {
+    const result = { mediaId: existing, reused: true, uploaded: false };
+    args.cache.set(canonical, result);
+    return result;
+  }
+  if (args.dryRun) {
+    const result = { mediaId: null, reused: false, uploaded: true };
+    args.cache.set(canonical, result);
+    return result;
+  }
+  try {
+    let downloaded;
+    try {
+      downloaded = await download(canonical, args.timeoutMs, fetchImpl);
+    } catch {
+      downloaded = await download(args.url, args.timeoutMs, fetchImpl);
+    }
+    const created = await createDoc(payload, {
+      collection: args.mediaSlug,
+      data: { alt: args.alt || filenameOf(canonical) },
+      file: {
+        data: downloaded.buffer,
+        mimetype: downloaded.mimeType,
+        name: filenameOf(canonical),
+        size: downloaded.buffer.length
+      }
+    });
+    const mediaId = String(created.id);
+    await saveRecord(payload, {
+      jobId: args.jobId,
+      site: args.site,
+      sourceId: args.sourceId ?? null,
+      sourceKey: canonical,
+      sourceType: "media",
+      targetCollection: args.mediaSlug,
+      targetId: mediaId
+    });
+    const result = { mediaId, reused: false, uploaded: true };
+    args.cache.set(canonical, result);
+    return result;
+  } catch (error) {
+    return {
+      error: error instanceof Error ? error.message : String(error),
+      mediaId: null,
+      reused: false,
+      uploaded: false
+    };
+  }
+};
+
+// src/lib/authors.ts
+var avatarUrl = (wpUser) => {
+  const urls = wpUser.avatar_urls;
+  if (!urls) {
+    return void 0;
+  }
+  const sizes = Object.keys(urls).map(Number).filter((n) => !Number.isNaN(n)).sort((a, b) => b - a);
+  return sizes.length ? urls[String(sizes[0])] : void 0;
+};
+var resolveAuthor = async (payload, args) => {
+  if (args.strategy === "fixed") {
+    return {
+      author: args.defaultUserId != null ? { field: "editor", value: args.defaultUserId } : null
+    };
+  }
+  const wpUser = args.wpUser;
+  if (!wpUser) {
+    return { author: args.defaultUserId != null ? { field: "editor", value: args.defaultUserId } : null };
+  }
+  const name = decodeEntities(wpUser.name ?? wpUser.slug ?? `author-${wpUser.id}`);
+  const existing = await findDoneRecord(payload, {
+    site: args.site,
+    sourceId: wpUser.id,
+    sourceType: "author"
+  });
+  if (args.strategy === "users") {
+    const field2 = "editor";
+    if (existing) {
+      return { author: { field: field2, value: existing } };
+    }
+    const email = wpUser.email || (args.syntheticEmailDomain ? `${wpUser.slug || `author-${wpUser.id}`}@${args.syntheticEmailDomain}` : null);
+    if (!email) {
+      return {
+        author: args.defaultUserId != null ? { field: field2, value: args.defaultUserId } : null,
+        skippedNoEmail: { name, sourceId: wpUser.id }
+      };
+    }
+    if (args.dryRun) {
+      return { author: null, imported: { sourceId: wpUser.id, targetId: "dry-run", title: name } };
+    }
+    const { docs } = await findDocs(payload, {
+      collection: args.usersSlug,
+      where: { email: { equals: email } },
+      limit: 1,
+      depth: 0
+    });
+    let userId = docs[0]?.id;
+    if (!userId) {
+      const created2 = await createDoc(payload, {
+        collection: args.usersSlug,
+        data: {
+          email,
+          name,
+          password: crypto.randomBytes(18).toString("hex")
+        }
+      });
+      userId = created2.id;
+    }
+    await saveRecord(payload, {
+      jobId: args.jobId,
+      site: args.site,
+      sourceId: wpUser.id,
+      sourceType: "author",
+      targetCollection: args.usersSlug,
+      targetId: userId
+    });
+    return {
+      author: { field: field2, value: userId },
+      imported: { sourceId: wpUser.id, targetId: userId, title: name }
+    };
+  }
+  const field = "author";
+  if (existing) {
+    return { author: { field, value: existing } };
+  }
+  if (args.dryRun) {
+    return { author: null, imported: { sourceId: wpUser.id, targetId: "dry-run", title: name } };
+  }
+  const avatar = avatarUrl(wpUser);
+  let pictureId = null;
+  if (avatar) {
+    const result = await importImage(payload, {
+      cache: args.imageCache,
+      dryRun: args.dryRun,
+      fetchImpl: args.fetchImpl,
+      jobId: args.jobId,
+      mediaSlug: args.mediaSlug,
+      site: args.site,
+      timeoutMs: args.timeoutMs,
+      url: avatar
+    });
+    pictureId = result.mediaId;
+  }
+  const created = await createDoc(payload, {
+    collection: args.authorsSlug,
+    data: {
+      name,
+      ...pictureId ? { picture: coerceId(pictureId) } : {},
+      ...wpUser.description ? { biography: decodeEntities(wpUser.description) } : {}
+    }
+  });
+  const authorId = created.id;
+  await saveRecord(payload, {
+    jobId: args.jobId,
+    site: args.site,
+    sourceId: wpUser.id,
+    sourceType: "author",
+    targetCollection: args.authorsSlug,
+    targetId: authorId
+  });
+  return {
+    author: { field, value: authorId },
+    imported: { sourceId: wpUser.id, targetId: authorId, title: name }
+  };
+};
+
+// src/lib/categories.ts
+var sortCategoriesParentsFirst = (categories) => {
+  const byId = new Map(categories.map((c) => [c.id, c]));
+  const sorted = [];
+  const placed = /* @__PURE__ */ new Set();
+  const place = (cat, stack) => {
+    if (placed.has(cat.id) || stack.has(cat.id)) {
+      return;
+    }
+    stack.add(cat.id);
+    const parent = cat.parent && cat.parent !== 0 ? byId.get(cat.parent) : void 0;
+    if (parent) {
+      place(parent, stack);
+    }
+    stack.delete(cat.id);
+    if (!placed.has(cat.id)) {
+      placed.add(cat.id);
+      sorted.push(cat);
+    }
+  };
+  for (const cat of categories) {
+    place(cat, /* @__PURE__ */ new Set());
+  }
+  return sorted;
+};
+var importCategories = async (payload, args) => {
+  const idMap = /* @__PURE__ */ new Map();
+  const imported = [];
+  const errors = [];
+  const ordered = sortCategoriesParentsFirst(args.categories);
+  for (const cat of ordered) {
+    try {
+      const existing = await findDoneRecord(payload, {
+        site: args.site,
+        sourceId: cat.id,
+        sourceType: "category"
+      });
+      if (existing) {
+        idMap.set(cat.id, coerceId(existing));
+        continue;
+      }
+      const name = decodeEntities(cat.name ?? cat.slug ?? `category-${cat.id}`);
+      if (args.dryRun) {
+        imported.push({ sourceId: cat.id, targetId: "dry-run", title: name });
+        continue;
+      }
+      const parentId = cat.parent && cat.parent !== 0 ? idMap.get(cat.parent) : void 0;
+      const created = await createDoc(payload, {
+        collection: args.categoriesSlug,
+        data: {
+          name,
+          ...cat.slug ? { slug: cat.slug } : {},
+          ...parentId != null ? { parent: coerceId(parentId) } : {},
+          ...cat.description ? { description: decodeEntities(cat.description) } : {}
+        }
+      });
+      const rawId = created.id;
+      idMap.set(cat.id, rawId);
+      imported.push({ sourceId: cat.id, targetId: rawId, title: name });
+      await saveRecord(payload, {
+        jobId: args.jobId,
+        site: args.site,
+        sourceId: cat.id,
+        sourceType: "category",
+        targetCollection: args.categoriesSlug,
+        targetId: rawId
+      });
+    } catch (error) {
+      errors.push({
+        message: error instanceof Error ? error.message : String(error),
+        scope: "category",
+        sourceId: cat.id
+      });
+    }
+  }
+  return { errors, idMap, imported };
+};
+
+// src/lib/content.ts
+import { convertHTMLToLexical } from "@payloadcms/richtext-lexical";
+import { JSDOM } from "jsdom";
+
+// src/lib/lexical.ts
+var imageToken = (index) => `\u2063WPIMG:${index}\u2063`;
+var IMAGE_TOKEN_RE = /^⁣WPIMG:(\d+)⁣$/;
+var buildUploadNode = (value, relationTo) => ({
+  type: "upload",
+  fields: null,
+  format: "",
+  relationTo,
+  value: coerceId(value),
+  version: 3
+});
+var walk = (node, visit) => {
+  visit(node);
+  if (Array.isArray(node.children)) {
+    for (const child of node.children) {
+      walk(child, visit);
+    }
+  }
+};
+var soleTextTokenIndex = (node) => {
+  if (node.type !== "paragraph" || !Array.isArray(node.children) || node.children.length !== 1) {
+    return null;
+  }
+  const child = node.children[0];
+  if (child.type !== "text" || typeof child.text !== "string") {
+    return null;
+  }
+  const m = IMAGE_TOKEN_RE.exec(child.text.trim());
+  return m ? Number(m[1]) : null;
+};
+var replaceImageTokens = (root, resolve, mediaSlug) => {
+  const replaceIn = (parent) => {
+    if (!Array.isArray(parent.children)) {
+      return;
+    }
+    const next = [];
+    for (const child of parent.children) {
+      const index = soleTextTokenIndex(child);
+      if (index !== null) {
+        const mediaId = resolve(index);
+        if (mediaId !== null && mediaId !== void 0) {
+          next.push(buildUploadNode(mediaId, mediaSlug));
+        }
+        continue;
+      }
+      replaceIn(child);
+      next.push(child);
+    }
+    parent.children = next;
+  };
+  replaceIn(root);
+  return root;
+};
+var takeFirstUploadNode = (root) => {
+  const search = (parent) => {
+    if (!Array.isArray(parent.children)) {
+      return null;
+    }
+    for (let i = 0; i < parent.children.length; i += 1) {
+      const child = parent.children[i];
+      if (child.type === "upload") {
+        parent.children.splice(i, 1);
+        return child.value ?? null;
+      }
+      const nested = search(child);
+      if (nested !== null) {
+        return nested;
+      }
+    }
+    return null;
+  };
+  return search(root);
+};
+var isEmptyParagraph = (node) => node.type === "paragraph" && (!Array.isArray(node.children) || node.children.every((child) => child.type === "text" && !(child.text ?? "").trim()));
+var removeLeadingUploadNode = (root, value) => {
+  const children = root.children;
+  if (!Array.isArray(children)) {
+    return false;
+  }
+  for (let i = 0; i < children.length; i += 1) {
+    const child = children[i];
+    if (isEmptyParagraph(child)) {
+      continue;
+    }
+    if (child.type === "upload" && String(child.value) === String(value)) {
+      children.splice(i, 1);
+      return true;
+    }
+    return false;
+  }
+  return false;
+};
+var rewriteLinkNodes = (root, options) => {
+  const { articleUrl, resolveInternal, siteHost } = options;
+  const links = [];
+  walk(root, (node) => {
+    if (node.type !== "link" || !node.fields) {
+      return;
+    }
+    const url = typeof node.fields.url === "string" ? node.fields.url : "";
+    if (!url || !isInternalUrl(url, siteHost)) {
+      return;
+    }
+    const slug = permalinkToSlug(url);
+    const targetSlug = resolveInternal(url, slug);
+    if (targetSlug) {
+      const to = articleUrl(targetSlug);
+      node.fields.url = to;
+      node.fields.linkType = "custom";
+      links.push({ action: "rewritten", from: url, to });
+    } else {
+      links.push({ action: "unresolved", from: url });
+    }
+  });
+  return links;
+};
+
+// src/lib/content.ts
+var buildContent = async (args) => {
+  const dom = new JSDOM(`<!DOCTYPE html><body>${args.html}</body>`);
+  const { document } = dom.window;
+  const images = [];
+  const tokenToMedia = /* @__PURE__ */ new Map();
+  const imgs = Array.from(document.querySelectorAll("img"));
+  let index = 0;
+  for (const img of imgs) {
+    const src = img.getAttribute("src") || "";
+    if (!src) {
+      img.remove();
+      continue;
+    }
+    const result = await args.importContentImage(src);
+    images.push({ result, src });
+    const token = index;
+    tokenToMedia.set(token, result.mediaId);
+    index += 1;
+    let target = img;
+    const anchor = img.parentElement;
+    if (anchor && anchor.tagName === "A" && anchor.childNodes.length === 1) {
+      target = anchor;
+    }
+    const figure = target.closest("figure");
+    if (figure) {
+      target = figure;
+    }
+    const placeholder = document.createElement("p");
+    placeholder.textContent = imageToken(token);
+    target.replaceWith(placeholder);
+  }
+  const modifiedHtml = document.body.innerHTML;
+  const state = convertHTMLToLexical({
+    editorConfig: args.editorConfig,
+    html: modifiedHtml,
+    JSDOM
+  });
+  replaceImageTokens(state.root, (i) => tokenToMedia.get(i) ?? null, args.mediaSlug);
+  const links = rewriteLinkNodes(state.root, {
+    articleUrl: args.articleUrl,
+    resolveInternal: args.resolveInternal,
+    siteHost: args.siteHost
+  });
+  return { content: state, images, links };
+};
+
+// src/lib/editorConfig.ts
+import { editorConfigFactory } from "@payloadcms/richtext-lexical";
+var findRichTextField = (fields, name) => {
+  for (const field of fields) {
+    if (field.type === "richText" && "name" in field && field.name === name) {
+      return field;
+    }
+    if ("fields" in field && Array.isArray(field.fields)) {
+      const nested = findRichTextField(field.fields, name);
+      if (nested) {
+        return nested;
+      }
+    }
+    if (field.type === "tabs" && Array.isArray(field.tabs)) {
+      for (const tab of field.tabs) {
+        const nested = findRichTextField(tab.fields, name);
+        if (nested) {
+          return nested;
+        }
+      }
+    }
+  }
+  return void 0;
+};
+var resolveEditorConfig = async (payload, articlesSlug, contentFieldName) => {
+  const collections = payload.collections;
+  const collection = collections[articlesSlug];
+  const field = collection ? findRichTextField(collection.config.fields, contentFieldName) : void 0;
+  if (field) {
+    return editorConfigFactory.fromField({ field });
+  }
+  return editorConfigFactory.default({ config: payload.config });
+};
+
+// src/lib/post.ts
+var selectPrimaryCategoryId = (post) => Array.isArray(post.categories) && post.categories.length > 0 ? post.categories[0] : null;
+var publishDate = (post) => {
+  if (post.date_gmt) {
+    const value = post.date_gmt.endsWith("Z") ? post.date_gmt : `${post.date_gmt}Z`;
+    const date = new Date(value);
+    return Number.isNaN(date.getTime()) ? void 0 : date.toISOString();
+  }
+  if (post.date) {
+    const date = new Date(post.date);
+    return Number.isNaN(date.getTime()) ? void 0 : date.toISOString();
+  }
+  return void 0;
+};
+
+// src/lib/redirects.ts
+var createRedirect = async (payload, args) => {
+  if (!payload.collections.redirects) {
+    return false;
+  }
+  const { totalDocs } = await countDocs(payload, {
+    collection: "redirects",
+    where: { from: { equals: args.from } }
+  });
+  if (totalDocs > 0) {
+    return false;
+  }
+  await createDoc(payload, {
+    collection: "redirects",
+    data: {
+      from: args.from,
+      to: {
+        type: "reference",
+        reference: { relationTo: args.articlesSlug, value: args.articleId }
+      }
+    }
+  });
+  return true;
+};
+
+// src/lib/report.ts
+var emptyProgress = () => ({
+  currentPhase: "queued",
+  cursorPage: 0,
+  importedAuthors: 0,
+  importedCategories: 0,
+  importedMedia: 0,
+  importedPosts: 0,
+  linksRewritten: 0,
+  linksUnresolved: 0,
+  redirectsCreated: 0,
+  reusedMedia: 0,
+  skippedPosts: 0,
+  failedPosts: 0,
+  totalPosts: 0
+});
+var emptyReport = (dryRun) => ({
+  dryRun,
+  errors: [],
+  imported: { authors: [], categories: [], media: [], posts: [] },
+  links: [],
+  remaining: { posts: 0 }
+});
+var rehydrateReport = (job, dryRun) => {
+  const previousRuns = Array.isArray(job.runs) ? job.runs : [];
+  const dryRunNumbers = new Set(previousRuns.filter((r) => r.dryRun).map((r) => r.run));
+  const keep = (items) => (items ?? []).filter((item) => item.run === void 0 || !dryRunNumbers.has(item.run));
+  const report = emptyReport(dryRun);
+  report.imported.authors = keep(job.authorsReport?.imported);
+  report.imported.categories = keep(job.categoriesReport?.imported);
+  report.imported.media = keep(job.mediaReport?.imported);
+  report.imported.posts = keep(job.postsReport?.imported);
+  report.links = keep(job.linksReport?.links);
+  report.errors = keep(job.errorsReport?.errors);
+  const runNumber = previousRuns.reduce((max, r) => Math.max(max, r.run), 0) + 1;
+  return { previousRuns, report, runNumber };
+};
+
+// src/lib/wpClient.ts
+var restBase = (siteUrl) => {
+  const trimmed = siteUrl.trim().replace(/\/+$/, "");
+  return `${trimmed}/wp-json/wp/v2`;
+};
+var WPRequestError = class extends Error {
+  status;
+  constructor(message, status) {
+    super(message);
+    this.name = "WPRequestError";
+    this.status = status;
+  }
+};
+var createWPClient = (siteUrl, request, fetchImpl = fetch) => {
+  const base = restBase(siteUrl);
+  const headers = { Accept: "application/json" };
+  if (request.userAgent) {
+    headers["User-Agent"] = request.userAgent;
+  }
+  const { applicationPassword, username } = request.credentials ?? {};
+  const authenticated2 = Boolean(username && applicationPassword);
+  if (authenticated2) {
+    headers.Authorization = `Basic ${Buffer.from(`${username}:${applicationPassword}`).toString("base64")}`;
+  }
+  const get = async (path) => {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), request.timeoutMs);
+    try {
+      const res = await fetchImpl(`${base}${path}`, { headers, signal: controller.signal });
+      if (!res.ok) {
+        throw new WPRequestError(`WordPress request failed: ${res.status} ${path}`, res.status);
+      }
+      const totalPages = Number(res.headers.get("X-WP-TotalPages") ?? "1") || 1;
+      const body = await res.json();
+      return { body, totalPages };
+    } finally {
+      clearTimeout(timer);
+    }
+  };
+  return {
+    authenticated: authenticated2,
+    fetchPostsPage: async ({ after, before, page, perPage }) => {
+      const params = new URLSearchParams({
+        _embed: "1",
+        page: String(page),
+        per_page: String(perPage),
+        status: "publish"
+      });
+      if (after) {
+        params.set("after", after);
+      }
+      if (before) {
+        params.set("before", before);
+      }
+      const { body, totalPages } = await get(`/posts?${params.toString()}`);
+      return { posts: body ?? [], totalPages };
+    },
+    fetchCategories: async () => {
+      const all = [];
+      let page = 1;
+      let totalPages = 1;
+      do {
+        const { body, totalPages: tp } = await get(`/categories?per_page=100&page=${page}`);
+        all.push(...body ?? []);
+        totalPages = tp;
+        page += 1;
+      } while (page <= totalPages);
+      return all;
+    },
+    fetchMedia: async (id) => {
+      try {
+        const { body } = await get(`/media/${id}`);
+        return body;
+      } catch {
+        return null;
+      }
+    },
+    fetchUser: async (id) => {
+      if (authenticated2) {
+        try {
+          const { body } = await get(`/users/${id}?context=edit`);
+          return body;
+        } catch {
+        }
+      }
+      try {
+        const { body } = await get(`/users/${id}`);
+        return body;
+      } catch {
+        return null;
+      }
+    }
+  };
+};
+
+// src/jobs/runImport.ts
+var PER_PAGE = 100;
+var SEO_DESCRIPTION_MAX = 150;
+var runImport = async (payload, args) => {
+  const { options } = args;
+  const { collections: slugs } = options;
+  const progress = emptyProgress();
+  const job = await findDoc(payload, {
+    collection: JOBS_SLUG,
+    id: args.jobId,
+    depth: 0
+  });
+  const dryRun = Boolean(job.dryRun);
+  const { previousRuns, report, runNumber } = rehydrateReport(job, dryRun);
+  const runSummary = {
+    dryRun,
+    run: runNumber,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    status: "running"
+  };
+  const runs = [...previousRuns, runSummary];
+  const site = hostOf(job.sourceUrl) ?? job.sourceUrl;
+  const imageCache = /* @__PURE__ */ new Map();
+  const stepReports = () => ({
+    authorsReport: { imported: report.imported.authors },
+    categoriesReport: { imported: report.imported.categories },
+    errorsReport: { dryRun: report.dryRun, errors: report.errors },
+    linksReport: { links: report.links },
+    mediaReport: { imported: report.imported.media, reused: progress.reusedMedia },
+    postsReport: {
+      dryRun: report.dryRun,
+      imported: report.imported.posts,
+      remaining: report.remaining.posts
+    },
+    runs
+  });
+  const updateJob = async (data) => {
+    await updateDoc(payload, {
+      collection: JOBS_SLUG,
+      id: args.jobId,
+      data,
+      context: { wpImport: true }
+    });
+  };
+  const accountImage = (result, sourceId) => {
+    if (result.error) {
+      report.errors.push({ message: result.error, run: runNumber, scope: "media", sourceId });
+    } else if (result.uploaded) {
+      progress.importedMedia += 1;
+      report.imported.media.push({
+        run: runNumber,
+        sourceId,
+        targetId: result.mediaId ?? "dry-run"
+      });
+    } else if (result.reused) {
+      progress.reusedMedia += 1;
+    }
+  };
+  try {
+    progress.currentPhase = "running";
+    await updateJob({
+      status: "running",
+      startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      progress,
+      ...stepReports()
+    });
+    const editorConfig = await resolveEditorConfig(payload, slugs.articles, options.fieldMap.content);
+    const client = createWPClient(
+      job.sourceUrl,
+      {
+        credentials: job.credentials,
+        timeoutMs: options.request.timeoutMs,
+        userAgent: options.request.userAgent
+      },
+      args.fetchImpl
+    );
+    progress.currentPhase = "categories";
+    const wpCategories = await client.fetchCategories();
+    const categoriesResult = await importCategories(payload, {
+      categories: wpCategories,
+      categoriesSlug: slugs.categories,
+      dryRun,
+      jobId: args.jobId,
+      site
+    });
+    const categoryIdMap = categoriesResult.idMap;
+    report.imported.categories.push(
+      ...categoriesResult.imported.map((item) => ({ ...item, run: runNumber }))
+    );
+    report.errors.push(...categoriesResult.errors.map((error) => ({ ...error, run: runNumber })));
+    progress.importedCategories = categoriesResult.imported.length;
+    await updateJob({ progress, ...stepReports() });
+    progress.currentPhase = "posts";
+    const after = job.dateFrom ? new Date(job.dateFrom).toISOString() : void 0;
+    const before = job.dateTo ? new Date(job.dateTo).toISOString() : void 0;
+    const maxPages = dryRun ? options.dryRunPageLimit : Number.POSITIVE_INFINITY;
+    const limit = job.limit ?? void 0;
+    const gathered = [];
+    let page = 1;
+    let totalPages = 1;
+    do {
+      const { posts, totalPages: tp } = await client.fetchPostsPage({ after, before, page, perPage: PER_PAGE });
+      totalPages = tp;
+      gathered.push(...posts);
+      progress.cursorPage = page;
+      page += 1;
+    } while (page <= totalPages && page <= maxPages && (!limit || gathered.length < limit));
+    const postsToImport = limit ? gathered.slice(0, limit) : gathered;
+    progress.totalPosts = postsToImport.length;
+    const existingArticles = await findDocs(payload, {
+      collection: slugs.articles,
+      depth: 0,
+      limit: 1e5,
+      select: { slug: true }
+    });
+    const knownSlugs = new Set(
+      existingArticles.docs.map((d) => d.slug).filter(Boolean)
+    );
+    const slugByPath = /* @__PURE__ */ new Map();
+    for (const p of postsToImport) {
+      if (p.slug) {
+        knownSlugs.add(p.slug);
+        if (p.link) {
+          slugByPath.set(pathOf(p.link), p.slug);
+        }
+      }
+    }
+    const resolveInternal = (url, slug) => {
+      const byPath = slugByPath.get(pathOf(url));
+      if (byPath) {
+        return byPath;
+      }
+      const candidate = slug ?? permalinkToSlug(url);
+      return candidate && knownSlugs.has(candidate) ? candidate : null;
+    };
+    const authorDetailCache = /* @__PURE__ */ new Map();
+    const enrichAuthor = async (embedded) => {
+      if (!embedded || embedded.email || !client.authenticated) {
+        return embedded;
+      }
+      if (!authorDetailCache.has(embedded.id)) {
+        authorDetailCache.set(embedded.id, await client.fetchUser(embedded.id));
+      }
+      const detailed = authorDetailCache.get(embedded.id);
+      return detailed?.email ? { ...embedded, email: detailed.email } : embedded;
+    };
+    for (const post of postsToImport) {
+      const permalinkPath = post.link ? pathOf(post.link) : `/?p=${post.id}`;
+      try {
+        const already = await findDoneRecord(payload, { site, sourceId: post.id, sourceType: "post" });
+        if (already) {
+          progress.skippedPosts += 1;
+          continue;
+        }
+        let coverId = null;
+        let featured = post._embedded?.["wp:featuredmedia"]?.[0];
+        if (!featured?.source_url && post.featured_media) {
+          featured = await client.fetchMedia(post.featured_media) ?? void 0;
+        }
+        if (featured?.source_url) {
+          const result = await importImage(payload, {
+            alt: featured.alt_text,
+            cache: imageCache,
+            dryRun,
+            fetchImpl: args.fetchImpl,
+            jobId: args.jobId,
+            mediaSlug: slugs.media,
+            site,
+            sourceId: featured.id,
+            timeoutMs: options.request.timeoutMs,
+            url: featured.source_url
+          });
+          coverId = result.mediaId;
+          accountImage(result, featured.id);
+        }
+        const built = await buildContent({
+          articleUrl: options.articleUrl,
+          editorConfig,
+          html: post.content?.rendered ?? "",
+          importContentImage: (src) => importImage(payload, {
+            cache: imageCache,
+            dryRun,
+            fetchImpl: args.fetchImpl,
+            jobId: args.jobId,
+            mediaSlug: slugs.media,
+            site,
+            timeoutMs: options.request.timeoutMs,
+            url: src
+          }),
+          mediaSlug: slugs.media,
+          resolveInternal,
+          siteHost: site
+        });
+        for (const img of built.images) {
+          accountImage(img.result, post.id);
+        }
+        report.links.push(...built.links.map((link) => ({ ...link, run: runNumber })));
+        for (const link of built.links) {
+          if (link.action === "rewritten") {
+            progress.linksRewritten += 1;
+          } else if (link.action === "unresolved") {
+            progress.linksUnresolved += 1;
+          }
+        }
+        if (!coverId && options.firstImageAsCover) {
+          const promoted = takeFirstUploadNode(built.content.root);
+          if (promoted != null) {
+            coverId = String(promoted);
+          }
+        } else if (coverId) {
+          removeLeadingUploadNode(built.content.root, coverId);
+        }
+        const {
+          author,
+          imported: importedAuthor,
+          skippedNoEmail
+        } = await resolveAuthor(payload, {
+          authorsSlug: slugs.authors,
+          defaultUserId: options.authorMapping.defaultUserId,
+          dryRun,
+          fetchImpl: args.fetchImpl,
+          imageCache,
+          jobId: args.jobId,
+          mediaSlug: slugs.media,
+          site,
+          strategy: options.authorMapping.strategy,
+          syntheticEmailDomain: options.authorMapping.syntheticEmailDomain,
+          timeoutMs: options.request.timeoutMs,
+          usersSlug: slugs.users,
+          wpUser: await enrichAuthor(post._embedded?.author?.[0])
+        });
+        if (importedAuthor) {
+          progress.importedAuthors += 1;
+          report.imported.authors.push({ ...importedAuthor, run: runNumber });
+        }
+        if (skippedNoEmail && !report.errors.some(
+          (e) => e.scope === "author" && e.sourceId === skippedNoEmail.sourceId
+        )) {
+          report.errors.push({
+            message: `author "${skippedNoEmail.name}" has no email exposed by WordPress; user creation skipped (set authorMapping.syntheticEmailDomain or defaultUserId)`,
+            run: runNumber,
+            scope: "author",
+            sourceId: skippedNoEmail.sourceId
+          });
+        }
+        const title = decodeEntities(post.title?.rendered ?? post.slug ?? `post-${post.id}`);
+        const primaryCategory = selectPrimaryCategoryId(post);
+        const categoryId = primaryCategory != null ? categoryIdMap.get(primaryCategory) : void 0;
+        const data = {
+          [options.fieldMap.title]: title,
+          [options.fieldMap.content]: built.content,
+          _status: "published"
+        };
+        if (post.slug) {
+          data[options.fieldMap.slug] = post.slug;
+        }
+        if (coverId) {
+          data[options.fieldMap.coverImage] = coerceId(coverId);
+        }
+        if (categoryId != null) {
+          data[options.fieldMap.category] = coerceId(categoryId);
+        }
+        const date = publishDate(post);
+        if (date) {
+          data[options.fieldMap.publishedAt] = date;
+        }
+        if (author) {
+          data[author.field] = coerceId(author.value);
+        }
+        const meta = { title };
+        if (coverId) {
+          meta.image = coerceId(coverId);
+        }
+        if (options.excerptToSeoDescription && post.excerpt?.rendered) {
+          meta.description = stripHtml(post.excerpt.rendered).slice(0, SEO_DESCRIPTION_MAX);
+        }
+        data.meta = meta;
+        if (dryRun) {
+          report.imported.posts.push({
+            run: runNumber,
+            slug: post.slug,
+            sourceId: post.id,
+            targetId: "dry-run",
+            title
+          });
+          progress.importedPosts += 1;
+          continue;
+        }
+        const created = await createDoc(payload, {
+          collection: slugs.articles,
+          data
+        });
+        const articleId = created.id;
+        await saveRecord(payload, {
+          jobId: args.jobId,
+          site,
+          sourceId: post.id,
+          sourceKey: permalinkPath,
+          sourceType: "post",
+          targetCollection: slugs.articles,
+          targetId: articleId
+        });
+        report.imported.posts.push({
+          run: runNumber,
+          slug: post.slug,
+          sourceId: post.id,
+          targetId: articleId,
+          title
+        });
+        progress.importedPosts += 1;
+        if (options.redirects) {
+          const made = await createRedirect(payload, {
+            articleId: coerceId(articleId),
+            articlesSlug: slugs.articles,
+            from: permalinkPath
+          });
+          if (made) {
+            progress.redirectsCreated += 1;
+            report.links.push({
+              action: "redirect",
+              from: permalinkPath,
+              run: runNumber,
+              to: options.articleUrl(post.slug)
+            });
+          }
+        }
+        if (progress.importedPosts % 5 === 0) {
+          await updateJob({ progress, ...stepReports() });
+        }
+      } catch (error) {
+        progress.failedPosts += 1;
+        const message = error instanceof Error ? error.message : String(error);
+        report.errors.push({ message, run: runNumber, scope: "post", sourceId: post.id });
+        if (!dryRun) {
+          await saveRecord(payload, {
+            error: message,
+            jobId: args.jobId,
+            site,
+            sourceId: post.id,
+            sourceType: "post",
+            status: "failed"
+          }).catch(() => void 0);
+        }
+      }
+    }
+    report.remaining.posts = Math.max(0, gathered.length - postsToImport.length);
+    progress.currentPhase = "done";
+    runSummary.finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+    runSummary.progress = { ...progress };
+    runSummary.status = "completed";
+    await updateJob({
+      finishedAt: runSummary.finishedAt,
+      progress,
+      status: "completed",
+      ...stepReports()
+    });
+    return report;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    report.errors.push({ message, run: runNumber, scope: "run" });
+    progress.currentPhase = "failed";
+    runSummary.finishedAt = (/* @__PURE__ */ new Date()).toISOString();
+    runSummary.progress = { ...progress };
+    runSummary.status = "failed";
+    await updateJob({
+      finishedAt: runSummary.finishedAt,
+      progress,
+      status: "failed",
+      ...stepReports()
+    });
+    return report;
+  }
+};
+
+// src/jobs/task.ts
+var importWordpressTask = (options) => ({
+  slug: TASK_SLUG,
+  handler: async ({ input, req }) => {
+    await runImport(req.payload, { jobId: input.jobId, options });
+    return { output: {} };
+  },
+  inputSchema: [{ name: "jobId", type: "text", required: true }]
+});
+
+// src/index.ts
+var LOG_PREFIX = "@composius/payload-plugin-import-wordpress";
+var ComposiusPayloadPluginImportWordpress = (pluginOptions = {}) => async (config) => {
+  if (!config.collections) {
+    config.collections = [];
+  }
+  const options = resolveOptions(pluginOptions);
+  const warnings = [];
+  config.collections.push(ImportJobs({ access: options.access }));
+  config.collections.push(ImportRecords({ access: options.access }));
+  config.jobs = {
+    ...config.jobs,
+    tasks: [...config.jobs?.tasks ?? [], importWordpressTask(options)]
+  };
+  if (pluginOptions.disabled) {
+    return config;
+  }
+  config.endpoints = [
+    ...config.endpoints ?? [],
+    startEndpoint(options.access),
+    statusEndpoint(options.access)
+  ];
+  if (pluginOptions.autoRun) {
+    const schedule = typeof pluginOptions.autoRun === "object" ? pluginOptions.autoRun : {};
+    const entry = { cron: schedule.cron ?? "* * * * *", queue: schedule.queue ?? "default" };
+    const existing = config.jobs.autoRun;
+    if (existing === void 0) {
+      config.jobs.autoRun = [entry];
+    } else if (Array.isArray(existing)) {
+      config.jobs.autoRun = [...existing, entry];
+    } else {
+      warnings.push("`jobs.autoRun` is a function; skipping the plugin auto-run schedule.");
+    }
+  }
+  if (options.redirects) {
+    try {
+      const { redirectsPlugin } = await import("@payloadcms/plugin-redirects");
+      config = redirectsPlugin({
+        collections: [options.collections.articles]
+      })(config);
+    } catch {
+      warnings.push(
+        "`redirects` is enabled but `@payloadcms/plugin-redirects` is not installed; redirects will be skipped."
+      );
+    }
+  }
+  if (warnings.length > 0) {
+    const incomingOnInit = config.onInit;
+    config.onInit = async (payload) => {
+      if (incomingOnInit) {
+        await incomingOnInit(payload);
+      }
+      for (const warning of warnings) {
+        payload.logger.warn(`[${LOG_PREFIX}] ${warning}`);
+      }
+    };
+  }
+  return config;
+};
+export {
+  ComposiusPayloadPluginImportWordpress
+};
+//# sourceMappingURL=index.js.map