woo2emdash 0.1.0

package/dist/config.js

@@ -0,0 +1,91 @@
+import { parseArgs } from "node:util";
+const OPTIONS = {
+    "woo-url": { type: "string" },
+    "woo-key": { type: "string" },
+    "woo-secret": { type: "string" },
+    "emdash-url": { type: "string" },
+    "emdash-token": { type: "string" },
+    lang: { type: "string" },
+    locale: { type: "string" },
+    out: { type: "string" },
+    pattern: { type: "string" },
+    since: { type: "string" },
+    limit: { type: "string" },
+    json: { type: "boolean", default: false },
+    "dry-run": { type: "boolean", default: false },
+    "skip-media": { type: "boolean", default: false },
+    "skip-variations": { type: "boolean", default: false },
+    help: { type: "boolean", short: "h", default: false },
+};
+export function parseCli(argv) {
+    const { values, positionals } = parseArgs({ args: argv, options: OPTIONS, allowPositionals: true });
+    const env = process.env;
+    const woo = () => {
+        const url = values["woo-url"] ?? env.WOO_URL;
+        const consumerKey = values["woo-key"] ?? env.WOO_CONSUMER_KEY;
+        const consumerSecret = values["woo-secret"] ?? env.WOO_CONSUMER_SECRET;
+        if (!url || !consumerKey || !consumerSecret) {
+            throw new Error("WooCommerce connection missing. Pass --woo-url, --woo-key and --woo-secret, or set WOO_URL, WOO_CONSUMER_KEY and WOO_CONSUMER_SECRET.");
+        }
+        return { url: url.replace(/\/+$/, ""), consumerKey, consumerSecret };
+    };
+    const emdash = () => ({
+        url: (values["emdash-url"] ?? env.EMDASH_URL ?? "http://127.0.0.1:4321").replace(/\/+$/, ""),
+        token: values["emdash-token"] ?? env.EMDASH_TOKEN,
+    });
+    if (values.since !== undefined && Number.isNaN(new Date(values.since).getTime())) {
+        throw new Error("--since must be an ISO 8601 date, e.g. 2026-09-01 or 2026-09-01T00:00:00Z.");
+    }
+    const limitRaw = values.limit;
+    const limit = limitRaw === undefined ? undefined : Number.parseInt(limitRaw, 10);
+    if (limit !== undefined && (!Number.isInteger(limit) || limit < 1)) {
+        throw new Error("--limit must be a positive integer.");
+    }
+    return {
+        command: positionals,
+        flags: {
+            json: values.json,
+            dryRun: values["dry-run"],
+            help: values.help,
+            lang: values.lang,
+            locale: values.locale,
+            out: values.out,
+            pattern: values.pattern,
+            since: values.since,
+            limit,
+            skipMedia: values["skip-media"],
+            skipVariations: values["skip-variations"],
+        },
+        woo,
+        emdash,
+    };
+}
+export const HELP = `woo2emdash <command> [options]
+
+Commands
+  analyze          Read the WooCommerce catalog and report what would be imported
+  schema show      Print the target EmDash schema (collections, fields, taxonomies)
+  schema apply     Create the target schema in EmDash, skipping anything that already exists
+  import           Copy terms, products, variations and images into EmDash (safe to re-run)
+  redirects        Write a redirect map from the old WooCommerce product URLs to the EmDash ones
+
+Connection (flags override environment variables)
+  --woo-url <url>          WOO_URL              Store URL, e.g. https://shop.example.com
+  --woo-key <ck_...>       WOO_CONSUMER_KEY     WooCommerce REST API consumer key (Read permission is enough)
+  --woo-secret <cs_...>    WOO_CONSUMER_SECRET  WooCommerce REST API consumer secret
+  --emdash-url <url>       EMDASH_URL           EmDash site URL (default http://127.0.0.1:4321)
+  --emdash-token <token>   EMDASH_TOKEN         EmDash API token. Omitted on localhost, the dev bypass is used.
+
+Options
+  --lang <code>            Only products whose permalink starts with /<code>/ (multilingual stores)
+  --locale <code>          Store entries and terms under this EmDash locale (must be configured on the site)
+  --out <file>             redirects: write the map to this file instead of stdout
+  --pattern <pattern>      redirects: destination pattern, e.g. /products/{slug} (default: the collection's URL pattern)
+  --since <date>           import: only products modified in WooCommerce after this date (incremental runs)
+  --limit <n>              Stop after n products (for quick checks)
+  --dry-run                Report what would happen without writing to EmDash
+  --skip-media             Do not download or upload images
+  --skip-variations        Import products only
+  --json                   Machine-readable output
+  -h, --help               This text
+`;

package/dist/emdash/client.js

@@ -0,0 +1,174 @@
+/**
+ * Thin client for the documented EmDash REST API (/_emdash/api). Kept independent
+ * of the `emdash` npm package on purpose, that package drags the whole CMS and its
+ * Astro peer dependencies into any tool that imports it.
+ *
+ * Auth: Bearer API token when given. On localhost with no token, the dev bypass
+ * endpoint issues a session cookie (the same trick the official CLI uses). It
+ * returns 403 on production sites, so it cannot be abused there.
+ */
+export class EmDashClient {
+    base;
+    origin;
+    token;
+    cookie = null;
+    bypassPromise = null;
+    constructor(cfg) {
+        this.base = `${cfg.url}/_emdash/api`;
+        this.origin = new URL(cfg.url).origin;
+        this.token = cfg.token;
+    }
+    async devBypass() {
+        const res = await fetch(`${this.base}/auth/dev-bypass`, { redirect: "manual" });
+        const setCookie = res.headers.get("set-cookie");
+        const match = setCookie?.match(/^([^=]+=[^;]+)/);
+        if (match)
+            this.cookie = match[1] ?? null;
+        if (res.body)
+            await res.text().catch(() => undefined);
+        if (!this.cookie) {
+            throw new Error(`EmDash dev bypass gave no session (HTTP ${res.status}). Pass --emdash-token for a non-local site.`);
+        }
+    }
+    async headers(method) {
+        const h = new Headers({ Accept: "application/json" });
+        if (this.token) {
+            h.set("Authorization", `Bearer ${this.token}`);
+        }
+        else {
+            if (!this.cookie) {
+                this.bypassPromise ??= this.devBypass();
+                await this.bypassPromise;
+            }
+            if (this.cookie)
+                h.set("Cookie", this.cookie);
+        }
+        if (method !== "GET") {
+            // CSRF header EmDash expects on mutations, plus Origin for Astro's own check.
+            h.set("X-EmDash-Request", "1");
+            h.set("Origin", this.origin);
+        }
+        return h;
+    }
+    async request(method, path, body) {
+        const h = await this.headers(method);
+        let payload = null;
+        if (body instanceof FormData) {
+            payload = body;
+        }
+        else if (body !== undefined) {
+            h.set("Content-Type", "application/json");
+            payload = JSON.stringify(body);
+        }
+        const res = await fetch(`${this.base}${path}`, { method, headers: h, body: payload });
+        const text = await res.text();
+        let json = {};
+        try {
+            json = text ? JSON.parse(text) : {};
+        }
+        catch {
+            throw new Error(`EmDash ${res.status} on ${method} ${path}: non-JSON response`);
+        }
+        if (!res.ok || json.success === false) {
+            const err = json.error ?? {};
+            throw new Error(`EmDash ${res.status} on ${method} ${path}: ${err.code ?? "error"} ${err.message ?? text.slice(0, 200)}`);
+        }
+        return json.data;
+    }
+    // Schema
+    async collections() {
+        const d = await this.request("GET", "/schema/collections");
+        return d.items;
+    }
+    async fields(collection) {
+        const d = await this.request("GET", `/schema/collections/${encodeURIComponent(collection)}/fields`);
+        return d.items ?? d.fields ?? [];
+    }
+    createCollection(body) {
+        return this.request("POST", "/schema/collections", body);
+    }
+    createField(collection, body) {
+        return this.request("POST", `/schema/collections/${encodeURIComponent(collection)}/fields`, body);
+    }
+    async collectionInfo(slug) {
+        const d = await this.request("GET", `/schema/collections/${encodeURIComponent(slug)}`);
+        return d.item;
+    }
+    async *allEntries(collection, locale) {
+        let cursor;
+        do {
+            const qs = new URLSearchParams({ limit: "100" });
+            if (cursor)
+                qs.set("cursor", cursor);
+            if (locale)
+                qs.set("locale", locale);
+            const d = await this.request("GET", `/content/${encodeURIComponent(collection)}?${qs}`);
+            for (const it of d.items)
+                yield it;
+            cursor = d.nextCursor ?? undefined;
+        } while (cursor);
+    }
+    // Taxonomies
+    async taxonomies() {
+        const d = await this.request("GET", "/taxonomies");
+        return d.taxonomies;
+    }
+    createTaxonomy(body) {
+        return this.request("POST", "/taxonomies", body);
+    }
+    /** Every term of a taxonomy, flattened (hierarchical taxonomies come back nested under `children`). */
+    async terms(taxonomy, locale) {
+        const qs = locale ? `?${new URLSearchParams({ locale })}` : "";
+        const d = await this.request("GET", `/taxonomies/${encodeURIComponent(taxonomy)}/terms${qs}`);
+        const out = [];
+        const walk = (list) => {
+            for (const t of list) {
+                out.push({ id: t.id, slug: t.slug, label: t.label });
+                if (t.children?.length)
+                    walk(t.children);
+            }
+        };
+        walk(d.terms ?? d.items ?? []);
+        return out;
+    }
+    async createTerm(taxonomy, body) {
+        const d = await this.request("POST", `/taxonomies/${encodeURIComponent(taxonomy)}/terms`, body);
+        const t = d.item ?? d.term ?? (d.id && d.slug ? { id: d.id, slug: d.slug } : undefined);
+        if (!t)
+            throw new Error(`Unexpected term response for ${taxonomy}/${String(body.slug)}: ${JSON.stringify(d).slice(0, 200)}`);
+        return t;
+    }
+    // Content
+    async findByField(collection, field, value, locale) {
+        const qs = new URLSearchParams({ limit: "2", fieldFilters: JSON.stringify({ [field]: value }) });
+        if (locale)
+            qs.set("locale", locale);
+        const d = await this.request("GET", `/content/${encodeURIComponent(collection)}?${qs}`);
+        return d.items[0];
+    }
+    async getEntry(collection, id) {
+        const d = await this.request("GET", `/content/${encodeURIComponent(collection)}/${encodeURIComponent(id)}`);
+        return { item: d.item, rev: d._rev };
+    }
+    async createEntry(collection, body) {
+        const d = await this.request("POST", `/content/${encodeURIComponent(collection)}`, body);
+        return d.item;
+    }
+    async updateEntry(collection, id, body) {
+        const d = await this.request("PUT", `/content/${encodeURIComponent(collection)}/${encodeURIComponent(id)}`, body);
+        return d.item;
+    }
+    async publishEntry(collection, id) {
+        await this.request("POST", `/content/${encodeURIComponent(collection)}/${encodeURIComponent(id)}/publish`);
+    }
+    async unpublishEntry(collection, id) {
+        await this.request("POST", `/content/${encodeURIComponent(collection)}/${encodeURIComponent(id)}/unpublish`);
+    }
+    // Media
+    async uploadMedia(bytes, filename, contentType) {
+        const form = new FormData();
+        form.append("file", new Blob([bytes], { type: contentType }), filename);
+        const d = await this.request("POST", "/media", form);
+        return { ...d.item, deduplicated: d.deduplicated === true };
+    }
+}

package/dist/import/convert.js

@@ -0,0 +1,177 @@
+import { gutenbergToPortableText, htmlToPortableText } from "@emdash-cms/gutenberg-to-portable-text";
+/** WooCommerce descriptions are either Gutenberg block markup or classic HTML. */
+export function toPortableText(html) {
+    const trimmed = html.trim();
+    if (trimmed === "")
+        return [];
+    return trimmed.includes("<!-- wp:") ? gutenbergToPortableText(trimmed) : htmlToPortableText(trimmed);
+}
+export function stripHtml(html) {
+    return html
+        .replace(/<br\s*\/?>/gi, "\n")
+        .replace(/<\/(p|div|li|h[1-6])>/gi, "\n")
+        .replace(/<[^>]+>/g, "")
+        .replace(/&nbsp;/g, " ")
+        .replace(/&amp;/g, "&")
+        .replace(/&lt;/g, "<")
+        .replace(/&gt;/g, ">")
+        .replace(/&quot;/g, '"')
+        .replace(/&#0?39;/g, "'")
+        .replace(/\n{3,}/g, "\n\n")
+        .trim();
+}
+export function num(v) {
+    if (v === null || v === undefined || v === "")
+        return undefined;
+    const n = typeof v === "number" ? v : Number.parseFloat(v);
+    return Number.isFinite(n) ? n : undefined;
+}
+export function int(v) {
+    const n = num(v);
+    return n === undefined ? undefined : Math.trunc(n);
+}
+/** wc/v3 GMT dates come without a zone suffix, e.g. 2026-03-22T10:11:12. */
+export function gmtDate(v) {
+    if (!v)
+        return undefined;
+    const iso = /Z$|[+-]\d\d:\d\d$/.test(v) ? v : `${v}Z`;
+    const d = new Date(iso);
+    return Number.isNaN(d.getTime()) ? undefined : d.toISOString();
+}
+export function str(v) {
+    return v === null || v === undefined || v === "" ? undefined : v;
+}
+/**
+ * Language of a product. WC Multilang 1.3.0+ reports it in `wcml_language`;
+ * older stores and other plugins fall back to the permalink's first path segment.
+ */
+export function productLanguage(p) {
+    if (typeof p.wcml_language === "string" && p.wcml_language !== "")
+        return p.wcml_language.toLowerCase();
+    return languagePrefix(p.permalink);
+}
+export function languagePrefix(permalink) {
+    try {
+        const first = new URL(permalink).pathname.split("/").filter(Boolean)[0] ?? "";
+        return /^[a-z]{2}(-[a-z]{2})?$/i.test(first) ? first.toLowerCase() : "(none)";
+    }
+    catch {
+        return "(none)";
+    }
+}
+function put(data, key, value) {
+    if (value !== undefined)
+        data[key] = value;
+}
+function commerceData(p, units) {
+    const d = {};
+    put(d, "sku", str(p.sku));
+    put(d, "gtin", str(p.global_unique_id));
+    put(d, "regular_price", num(p.regular_price));
+    put(d, "sale_price", num(p.sale_price));
+    put(d, "price", num(p.price));
+    put(d, "currency", units.currency);
+    put(d, "sale_from", gmtDate(p.date_on_sale_from_gmt));
+    put(d, "sale_to", gmtDate(p.date_on_sale_to_gmt));
+    put(d, "stock_status", p.stock_status);
+    put(d, "manage_stock", p.manage_stock);
+    put(d, "stock_quantity", int(p.stock_quantity));
+    put(d, "backorders", p.backorders);
+    put(d, "low_stock_amount", int(p.low_stock_amount));
+    put(d, "weight", num(p.weight));
+    put(d, "length", num(p.dimensions?.length));
+    put(d, "width", num(p.dimensions?.width));
+    put(d, "height", num(p.dimensions?.height));
+    put(d, "weight_unit", units.weightUnit);
+    put(d, "dimension_unit", units.dimensionUnit);
+    put(d, "shipping_class", str(p.shipping_class));
+    put(d, "tax_status", p.tax_status);
+    put(d, "tax_class", str(p.tax_class));
+    put(d, "virtual", p.virtual);
+    put(d, "downloadable", p.downloadable);
+    if (p.downloads.length > 0)
+        d.downloads = p.downloads;
+    put(d, "download_limit", int(p.download_limit));
+    put(d, "download_expiry", int(p.download_expiry));
+    return d;
+}
+export function productData(p, units, attributeTaxonomy, featured, gallery) {
+    const d = {
+        title: p.name,
+        content: toPortableText(p.description),
+        product_type: ["simple", "variable", "grouped", "external"].includes(p.type) ? p.type : "simple",
+        ...commerceData(p, units),
+        featured: p.featured,
+        catalog_visibility: p.catalog_visibility,
+        menu_order: p.menu_order,
+        sold_individually: p.sold_individually,
+        reviews_allowed: p.reviews_allowed,
+        woo_id: p.id,
+        woo_permalink: p.permalink,
+    };
+    put(d, "excerpt", str(stripHtml(p.short_description)));
+    put(d, "featured_image", featured);
+    if (gallery.length > 0)
+        d.gallery = gallery.map((image) => ({ image }));
+    put(d, "external_url", str(p.external_url));
+    put(d, "button_text", str(p.button_text));
+    put(d, "purchase_note", str(stripHtml(p.purchase_note ?? "")));
+    put(d, "average_rating", num(p.average_rating));
+    put(d, "rating_count", int(p.rating_count));
+    if (p.attributes.length > 0) {
+        const attrs = p.attributes.map((a) => ({
+            name: a.name,
+            taxonomy: a.id > 0 && a.slug ? attributeTaxonomy(a.slug) : null,
+            woo_taxonomy: a.id > 0 && a.slug ? a.slug : null,
+            visible: a.visible,
+            variation: a.variation,
+            options: a.options,
+        }));
+        d.attributes = attrs;
+    }
+    if (p.default_attributes.length > 0)
+        d.default_attributes = p.default_attributes;
+    put(d, "woo_modified", gmtDate(p.date_modified_gmt));
+    return d;
+}
+export function variationData(v, parentTitle, parentEntryId, units, attributeTaxonomy, featured) {
+    const options = v.attributes.map((a) => a.option).filter(Boolean);
+    const d = {
+        title: str(v.name) ?? (options.length ? `${parentTitle} - ${options.join(", ")}` : `${parentTitle} #${v.id}`),
+        product: parentEntryId,
+        content: toPortableText(v.description),
+        ...commerceData(v, units),
+        menu_order: v.menu_order,
+        woo_id: v.id,
+        woo_permalink: v.permalink,
+    };
+    put(d, "featured_image", featured);
+    if (v.attributes.length > 0) {
+        d.attributes = v.attributes.map((a) => ({
+            name: a.name,
+            taxonomy: a.id > 0 && a.slug ? attributeTaxonomy(a.slug) : null,
+            woo_taxonomy: a.id > 0 && a.slug ? a.slug : null,
+            option: a.option,
+        }));
+    }
+    put(d, "woo_modified", gmtDate(v.date_modified_gmt));
+    return d;
+}
+/** WooCommerce percent-encodes non-ASCII slugs; EmDash wants a plain one. */
+export function entrySlug(wooSlug, fallbackId) {
+    let s = wooSlug;
+    try {
+        s = decodeURIComponent(s);
+    }
+    catch {
+        /* keep as is */
+    }
+    s = s
+        .normalize("NFKD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 180);
+    return s || `product-${fallbackId}`;
+}

package/dist/import/entries.js

@@ -0,0 +1,133 @@
+/**
+ * Idempotent writes keyed on the `woo_id` field. Each collection's entries are
+ * looked up by indexed field filter, so re-runs update instead of duplicating.
+ */
+export class EntryWriter {
+    known = new Map();
+    created = 0;
+    updated = 0;
+    client;
+    dryRun;
+    locale;
+    constructor(client, dryRun, locale) {
+        this.client = client;
+        this.dryRun = dryRun;
+        this.locale = locale;
+    }
+    entryFor(collection, wooId) {
+        return this.known.get(collection)?.get(wooId);
+    }
+    remember(collection, wooId, item) {
+        let m = this.known.get(collection);
+        if (!m) {
+            m = new Map();
+            this.known.set(collection, m);
+        }
+        m.set(wooId, item);
+    }
+    /** Lookup ignoring the run's locale, for finding a translation sibling imported in another language. */
+    async findAnyLocale(collection, wooId) {
+        return this.client.findByField(collection, "woo_id", wooId);
+    }
+    async find(collection, wooId) {
+        const cached = this.entryFor(collection, wooId);
+        if (cached)
+            return cached;
+        const found = await this.client.findByField(collection, "woo_id", wooId, this.locale);
+        if (found)
+            this.remember(collection, wooId, found);
+        return found;
+    }
+    /**
+     * Create or update one entry. `publish` mirrors WooCommerce's publish status;
+     * everything else lands as a draft.
+     */
+    async upsert(opts) {
+        const existing = await this.find(opts.collection, opts.wooId);
+        if (this.dryRun) {
+            const item = existing ?? { id: `dry-run:${opts.collection}:${opts.wooId}`, slug: opts.slug, status: "draft", data: {} };
+            if (existing)
+                this.updated += 1;
+            else
+                this.created += 1;
+            this.remember(opts.collection, opts.wooId, item);
+            return item;
+        }
+        if (!existing) {
+            // Always create as a draft and publish explicitly: the create endpoint's
+            // own publish behaviour was not consistent across entries in testing.
+            const body = { data: opts.data, slug: opts.slug, status: "draft" };
+            if (this.locale)
+                body.locale = this.locale;
+            if (opts.translationOf)
+                body.translationOf = opts.translationOf;
+            if (opts.createdAt) {
+                body.createdAt = opts.createdAt;
+                if (opts.publish)
+                    body.publishedAt = opts.createdAt;
+            }
+            if (opts.taxonomies && Object.keys(opts.taxonomies).length > 0)
+                body.taxonomies = opts.taxonomies;
+            let item;
+            try {
+                item = await this.client.createEntry(opts.collection, body);
+            }
+            catch (e) {
+                // Slug taken by an unrelated entry (multilingual duplicates, earlier manual content): retry with a unique slug.
+                if (e instanceof Error && /slug/i.test(e.message)) {
+                    body.slug = `${opts.slug}-${opts.wooId}`;
+                    item = await this.client.createEntry(opts.collection, body);
+                }
+                else {
+                    throw e;
+                }
+            }
+            if (opts.publish) {
+                await this.client.publishEntry(opts.collection, item.id);
+                item = { ...item, status: "published" };
+            }
+            this.created += 1;
+            this.remember(opts.collection, opts.wooId, item);
+            return item;
+        }
+        const body = { data: opts.data, skipRevision: true };
+        if (this.locale)
+            body.locale = this.locale;
+        if (existing.slug !== opts.slug && !existing.slug.startsWith(`${opts.slug}-`))
+            body.slug = opts.slug;
+        if (opts.taxonomies)
+            body.taxonomies = opts.taxonomies;
+        let item;
+        try {
+            item = await this.client.updateEntry(opts.collection, existing.id, body);
+        }
+        catch (e) {
+            if (body.slug && e instanceof Error && /slug/i.test(e.message)) {
+                delete body.slug;
+                item = await this.client.updateEntry(opts.collection, existing.id, body);
+            }
+            else {
+                throw e;
+            }
+        }
+        if (opts.publish)
+            await this.client.publishEntry(opts.collection, existing.id).catch(() => undefined);
+        if (!opts.publish && existing.status === "published")
+            await this.client.unpublishEntry(opts.collection, existing.id).catch(() => undefined);
+        this.updated += 1;
+        const merged = { ...item, status: opts.publish ? "published" : item.status };
+        this.remember(opts.collection, opts.wooId, merged);
+        return merged;
+    }
+    /** Second-pass update of a few fields (used for cross references once every id is known). */
+    async patch(collection, id, data, publish) {
+        if (this.dryRun)
+            return;
+        const body = { data, skipRevision: true };
+        if (this.locale)
+            body.locale = this.locale;
+        await this.client.updateEntry(collection, id, body);
+        if (publish)
+            await this.client.publishEntry(collection, id).catch(() => undefined);
+    }
+}

package/dist/import/images.js

@@ -0,0 +1,44 @@
+/**
+ * After HTML or Gutenberg conversion, image blocks still point at the
+ * WooCommerce upload URLs. Upload each one to EmDash media and repoint the
+ * block's asset reference at the EmDash media item. Walks nested structures
+ * (galleries, columns) generically, so it does not depend on the converter's
+ * block catalogue.
+ */
+export async function relinkImages(blocks, media) {
+    let relinked = 0;
+    const seen = new Map();
+    const walk = async (node) => {
+        if (Array.isArray(node))
+            return Promise.all(node.map(walk));
+        if (!node || typeof node !== "object")
+            return node;
+        const obj = { ...node };
+        if (obj._type === "image" && obj.asset && typeof obj.asset === "object") {
+            const asset = { ...obj.asset };
+            const url = typeof asset.url === "string" ? asset.url : "";
+            if (/^https?:\/\//i.test(url)) {
+                let p = seen.get(url);
+                if (!p) {
+                    p = media.fromUrl(url, typeof obj.alt === "string" ? obj.alt : "");
+                    seen.set(url, p);
+                }
+                const item = await p;
+                if (item) {
+                    asset._ref = item.id;
+                    if (item.src)
+                        asset.url = item.src;
+                    relinked += 1;
+                }
+            }
+            obj.asset = asset;
+        }
+        for (const [k, v] of Object.entries(obj)) {
+            if (k !== "asset" && (Array.isArray(v) || (v && typeof v === "object")))
+                obj[k] = await walk(v);
+        }
+        return obj;
+    };
+    const out = (await walk(blocks));
+    return { blocks: out, relinked };
+}

package/dist/import/media.js

@@ -0,0 +1,62 @@
+import { log } from "../log.js";
+/**
+ * Downloads WooCommerce images and uploads them to EmDash media. One upload
+ * per distinct source URL per run; EmDash itself deduplicates by content hash,
+ * so re-runs do not pile up copies either.
+ */
+export class MediaImporter {
+    cache = new Map();
+    uploaded = 0;
+    reused = 0;
+    failed = 0;
+    client;
+    dryRun;
+    constructor(client, dryRun) {
+        this.client = client;
+        this.dryRun = dryRun;
+    }
+    /** Same as image(), for a bare URL found inside description HTML. */
+    fromUrl(src, alt) {
+        return this.image({ id: 0, src, name: "", alt });
+    }
+    async image(img) {
+        if (!img?.src)
+            return undefined;
+        if (this.dryRun)
+            return { id: "dry-run", src: img.src, alt: img.alt };
+        let p = this.cache.get(img.src);
+        if (!p) {
+            p = this.fetchAndUpload(img);
+            this.cache.set(img.src, p);
+        }
+        return p;
+    }
+    async fetchAndUpload(img) {
+        try {
+            const res = await fetch(img.src, { headers: { "User-Agent": "woo2emdash/0.0.1" } });
+            if (!res.ok)
+                throw new Error(`HTTP ${res.status}`);
+            const bytes = new Uint8Array(await res.arrayBuffer());
+            const contentType = res.headers.get("content-type")?.split(";")[0] ?? "application/octet-stream";
+            const filename = decodeURIComponent(new URL(img.src).pathname.split("/").pop() || "image") || `image-${img.id}`;
+            const item = await this.client.uploadMedia(bytes, filename, contentType);
+            if (item.deduplicated)
+                this.reused += 1;
+            else
+                this.uploaded += 1;
+            const value = { id: item.id, src: item.url, filename: item.filename, mimeType: item.mimeType };
+            if (item.width !== undefined)
+                value.width = item.width;
+            if (item.height !== undefined)
+                value.height = item.height;
+            if (img.alt)
+                value.alt = img.alt;
+            return value;
+        }
+        catch (e) {
+            this.failed += 1;
+            log.warn(`image ${img.src}: ${e instanceof Error ? e.message : String(e)}`);
+            return undefined;
+        }
+    }
+}