@porulle/plugin-channel-connector 0.45.0 → 0.46.0

package/dist/index.d.ts

@@ -22,7 +22,7 @@ export declare const CHANNEL_IMPORT_MAX_ITEMS_PER_INVOCATION = 20;
  */
 export declare const CHANNEL_MAX_BATCHES_PER_SWEEP = 5000;
 export { signState, verifyState } from "./oauth-state.js";
-export type { BackfillCatalogOptions, BackfillCatalogReport, BuildCatalogPushItemsOptions, BuildCatalogPushItemsResult, CatalogPushAssemblyField, CatalogPushAssemblyImage, CatalogPushAssemblyItem, CatalogPushPreviewBefore, CatalogPushPreviewBeforeStatus, CatalogPushPreviewDiff, CatalogPushPreviewItem, CatalogPushPreviewResult, CatalogPushPreviewUnavailable, PushCatalogToStoreResult, CatalogPushJobResult, CatalogFieldConflict, CatalogFieldSkip, CatalogPushFieldSkip, CatalogPushSkipReason, CatalogConflictState, CatalogWriteSettings, ChannelComplianceData, ChannelConnectorPluginOptions, ChannelStockLine, ExportState, PublicConnectedStore, ReconcileReport, } from "./service.js";
+export type { BackfillCatalogOptions, BackfillCatalogReport, BuildCatalogPushItemsOptions, BuildCatalogPushItemsResult, CatalogPushAssemblyField, CatalogPushAssemblyImage, CatalogPushAssemblyItem, CatalogPushPreviewBefore, CatalogPushPreviewBeforeStatus, CatalogPushPreviewDiff, CatalogPushPreviewItem, CatalogPushPreviewResult, CatalogPushPreviewUnavailable, PushCatalogToStoreResult, CatalogPushJobResult, CatalogConvergenceFailure, CatalogFieldConflict, CatalogFieldSkip, CatalogPushFieldSkip, CatalogPushSkipReason, CatalogConflictState, CatalogWriteSettings, ChannelComplianceData, ChannelConnectorPluginOptions, ChannelStockLine, ExportState, PublicConnectedStore, ReconcileReport, } from "./service.js";
 export type { OAuthStatePayload, OAuthStateResult } from "./oauth-state.js";
 export type { ChannelCatalogPush, ChannelCatalogPushEvent, ChannelCatalogConflict, ChannelCatalogConflictEvent, ChannelEntityMapEntry, ChannelExportEvent, ChannelOrderExport, ChannelRefundEvent, ChannelRefundRequest, ConnectedStore, } from "./schema.js";
 export declare function channelConnectorPlugin(options?: ChannelConnectorPluginOptions): import("@porulle/core").CommercePlugin;

package/dist/service.d.ts

@@ -165,6 +165,14 @@ export interface BackfillCatalogReport extends BackfillCounts, Record<string, un
     conflicts?: CatalogFieldConflict[];
     warnings?: string[];
 }
+/**
+ * One item the converge loop could not finish. `externalId` is the merchant's id, because the
+ * entity may not exist yet and a caller reporting the failure has nothing else to name it by.
+ */
+export interface CatalogConvergenceFailure {
+    externalId: string;
+    error: string;
+}
 export interface BackfillCatalogOptions {
     dryRun?: boolean;
     resume?: boolean;
@@ -282,6 +290,7 @@ export declare class ChannelConnectorService {
         skipped?: CatalogFieldSkip[];
         conflicts?: CatalogFieldConflict[];
         warnings?: string[];
+        failures?: CatalogConvergenceFailure[];
     }>>;
     importCatalog(orgId: string, storeId: string, actor: Actor, options?: undefined): Promise<PluginResult<{
         imported: number;
@@ -289,6 +298,7 @@ export declare class ChannelConnectorService {
         skipped?: CatalogFieldSkip[];
         conflicts?: CatalogFieldConflict[];
         warnings?: string[];
+        failures?: CatalogConvergenceFailure[];
     }>>;
     private promoteLegacyAttributes;
     private saveBackfillState;

package/dist/service.js

@@ -1722,6 +1722,7 @@ export class ChannelConnectorService {
                 ...(result.value.skipped.length > 0 ? { skipped: uniqueSkipped(result.value.skipped) } : {}),
                 ...(result.value.conflicts.length > 0 ? { conflicts: result.value.conflicts } : {}),
                 ...(result.value.warnings.length > 0 ? { warnings: result.value.warnings } : {}),
+                ...(result.value.failures.length > 0 ? { failures: result.value.failures } : {}),
             });
         }
         let { pageCursor, offset } = parseImportResumePosition(store.catalogCursor);
@@ -1731,6 +1732,7 @@ export class ChannelConnectorService {
         const skipped = [];
         const conflicts = [];
         const warnings = [];
+        const failures = [];
         while (remaining > 0) {
             const page = await connector.importCatalog(store, pageCursor ?? undefined);
             if (!page.ok)
@@ -1756,6 +1758,7 @@ export class ChannelConnectorService {
             skipped.push(...result.value.skipped);
             conflicts.push(...result.value.conflicts);
             warnings.push(...result.value.warnings);
+            failures.push(...result.value.failures);
             offset += result.value.consumed;
             if (offset >= pageItems.length) {
                 if (page.value.nextCursor) {
@@ -1787,6 +1790,9 @@ export class ChannelConnectorService {
             ...(skipped.length > 0 ? { skipped: uniqueSkipped(skipped) } : {}),
             ...(conflicts.length > 0 ? { conflicts } : {}),
             ...(warnings.length > 0 ? { warnings } : {}),
+            // Always surfaced when non-empty. A silently dropped product is worse than the halt this
+            // replaced: the caller must be able to see which externalIds did not land.
+            ...(failures.length > 0 ? { failures } : {}),
         });
     }
     async promoteLegacyAttributes(orgId, storeId, actor, dryRun) {
@@ -1951,6 +1957,7 @@ export class ChannelConnectorService {
             skipped: [],
             conflicts: [],
             warnings: [],
+            failures: [], // a dry run converges nothing, so it can fail nothing
         };
         const assets = await this.db.select().from(mediaAssets).where(eq(mediaAssets.organizationId, orgId));
         for (const item of items) {
@@ -2082,196 +2089,212 @@ export class ChannelConnectorService {
         const skipped = [];
         const conflicts = [];
         const warnings = [];
+        const failures = [];
         for (const item of items) {
             consumed += 1;
-            const remoteHash = hash(item);
-            const existing = await this.db
-                .select()
-                .from(channelEntityMap)
-                .where(and(eq(channelEntityMap.organizationId, orgId), eq(channelEntityMap.storeId, storeId), eq(channelEntityMap.kind, "entity"), eq(channelEntityMap.externalId, item.externalId)));
-            let entityMapping = existing.find((entry) => entry.kind === "entity");
-            let entityId;
-            let isNew = false;
-            let adoptedOrphan = false;
-            let entityTouched = false;
-            let existingEntity;
-            if (entityMapping) {
-                const [entity] = await this.db.select().from(sellableEntities).where(and(eq(sellableEntities.organizationId, orgId), eq(sellableEntities.id, entityMapping.entityId)));
-                if (!entity) {
-                    await this.db.delete(channelEntityMap).where(and(eq(channelEntityMap.organizationId, orgId), eq(channelEntityMap.storeId, storeId), eq(channelEntityMap.entityId, entityMapping.entityId)));
-                    entityMapping = undefined;
+            try {
+                const remoteHash = hash(item);
+                const existing = await this.db
+                    .select()
+                    .from(channelEntityMap)
+                    .where(and(eq(channelEntityMap.organizationId, orgId), eq(channelEntityMap.storeId, storeId), eq(channelEntityMap.kind, "entity"), eq(channelEntityMap.externalId, item.externalId)));
+                let entityMapping = existing.find((entry) => entry.kind === "entity");
+                let entityId;
+                let isNew = false;
+                let adoptedOrphan = false;
+                let entityTouched = false;
+                let existingEntity;
+                if (entityMapping) {
+                    const [entity] = await this.db.select().from(sellableEntities).where(and(eq(sellableEntities.organizationId, orgId), eq(sellableEntities.id, entityMapping.entityId)));
+                    if (!entity) {
+                        await this.db.delete(channelEntityMap).where(and(eq(channelEntityMap.organizationId, orgId), eq(channelEntityMap.storeId, storeId), eq(channelEntityMap.entityId, entityMapping.entityId)));
+                        entityMapping = undefined;
+                    }
+                    else {
+                        entityId = entityMapping.entityId;
+                        existingEntity = entity;
+                    }
                 }
-                else {
-                    entityId = entityMapping.entityId;
-                    existingEntity = entity;
+                if (entityId === undefined) {
+                    const [orphan] = await this.db.select().from(sellableEntities).where(and(eq(sellableEntities.organizationId, orgId), eq(sellableEntities.sourceStoreId, storeId), eq(sellableEntities.slug, item.slug)));
+                    if (orphan) {
+                        entityId = orphan.id;
+                        existingEntity = orphan;
+                        adoptedOrphan = true;
+                    }
+                    else {
+                        const status = item.status;
+                        try {
+                            entityId = await this.transact(async (tx) => {
+                                const txContext = createTxContext(tx, { actor });
+                                const created = await this.catalog.create({
+                                    type: "product",
+                                    slug: item.slug,
+                                    sourceStoreId: storeId,
+                                    metadata: mergeMetadata(undefined, item.metadata ?? {}),
+                                    ...(status !== undefined ? { status, isVisible: status === "active" } : {}),
+                                }, actor, txContext);
+                                if (!created.ok)
+                                    throw new Error(created.error.message);
+                                await tx.insert(channelEntityMap).values({
+                                    organizationId: orgId,
+                                    storeId,
+                                    kind: "entity",
+                                    externalId: item.externalId,
+                                    entityId: created.value.id,
+                                    syncHash: PENDING_ENTITY_MAP_SYNC_HASH,
+                                    heldFieldPaths: [],
+                                    forcedPushFieldPaths: [],
+                                });
+                                return created.value.id;
+                            });
+                        }
+                        catch (error) {
+                            failures.push({ externalId: item.externalId, error: error instanceof Error ? error.message : "Failed to create catalog entity." });
+                            continue;
+                        }
+                        isNew = true;
+                        imported += 1;
+                        entityTouched = true;
+                    }
                 }
-            }
-            if (entityId === undefined) {
-                const [orphan] = await this.db.select().from(sellableEntities).where(and(eq(sellableEntities.organizationId, orgId), eq(sellableEntities.sourceStoreId, storeId), eq(sellableEntities.slug, item.slug)));
-                if (orphan) {
-                    entityId = orphan.id;
-                    existingEntity = orphan;
-                    adoptedOrphan = true;
+                const ownershipBeforeSeed = await this.catalog.resolveFieldOwners(entityId, storeId);
+                const seedPaths = importedFieldPaths(item).filter((path) => !ownershipBeforeSeed.has(path));
+                const seeded = await this.catalog.seedImportedFieldOwnership(entityId, storeId, seedPaths);
+                if (!seeded.ok) {
+                    failures.push({ externalId: item.externalId, error: seeded.error.message });
+                    continue;
                 }
-                else {
-                    const status = item.status;
-                    try {
-                        entityId = await this.transact(async (tx) => {
-                            const txContext = createTxContext(tx, { actor });
-                            const created = await this.catalog.create({
-                                type: "product",
-                                slug: item.slug,
-                                sourceStoreId: storeId,
-                                metadata: mergeMetadata(undefined, item.metadata ?? {}),
-                                ...(status !== undefined ? { status, isVisible: status === "active" } : {}),
-                            }, actor, txContext);
-                            if (!created.ok)
-                                throw new Error(created.error.message);
-                            await tx.insert(channelEntityMap).values({
-                                organizationId: orgId,
-                                storeId,
-                                kind: "entity",
-                                externalId: item.externalId,
-                                entityId: created.value.id,
-                                syncHash: PENDING_ENTITY_MAP_SYNC_HASH,
-                                heldFieldPaths: [],
-                                forcedPushFieldPaths: [],
-                            });
-                            return created.value.id;
-                        });
+                for (const path of seedPaths)
+                    ownershipBeforeSeed.set(path, "store");
+                const owners = ownershipBeforeSeed;
+                const outboundEcho = entityMapping ? this.isOutboundEcho(entityMapping, item) : false;
+                const remoteChanged = entityMapping === undefined || entityMapping.syncHash !== remoteHash;
+                // An unchanged remote item writes nothing and advances no baseline:
+                // converging a stale replay would revert local edits to shared and
+                // unowned fields that the store never actually changed.
+                if (!force && !remoteChanged && existingEntity && existingEntity.status !== "archived") {
+                    continue;
+                }
+                const shared = existingEntity
+                    ? await this.detectSharedConflicts(entityId, storeId, existingEntity, entityMapping, item, owners, importedFieldPaths(item), remoteHash, outboundEcho ? { certifiedPaths: new Set(entityMapping?.outboundFieldPaths ?? []) } : undefined)
+                    : { paths: [], conflicts: [] };
+                const persistedConflicts = await this.persistCatalogConflicts(orgId, shared.conflicts, requireUserId(actor));
+                if (!persistedConflicts.ok)
+                    return persistedConflicts;
+                const owned = this.filterOwnedFields(item, owners);
+                const heldSharedPaths = [...new Set([...(entityMapping?.heldFieldPaths ?? []), ...shared.paths])];
+                // A newly held path revokes any force left from an earlier resolution of
+                // that same path: the force was the operator's answer to a question that
+                // has since been asked again, and it must not pre-empt the new one.
+                const survivingForcedPaths = (entityMapping?.forcedPushFieldPaths ?? []).filter((path) => !heldSharedPaths.includes(path));
+                const held = this.filterConflictingFields(owned.writable, heldSharedPaths);
+                const writable = held.writable;
+                const blockedPaths = new Set([...owned.skipped, ...heldSharedPaths]);
+                skipped.push(...owned.skipped.map((fieldPath) => ({ entityId, fieldPath })));
+                conflicts.push(...shared.conflicts.map(({ platformValue: _platformValue, storeValue: _storeValue, ...conflict }) => conflict));
+                for (const conflict of shared.conflicts) {
+                    warnings.push(`Held shared field conflict for entity "${conflict.entityId}", store "${conflict.storeId}", field "${conflict.fieldPath}" (local ${conflict.localValueSummary}, remote ${conflict.remoteValueSummary}).`);
+                }
+                if (existingEntity && entityMapping) {
+                    const remoteMetadata = mergeMetadata(existingEntity.metadata, writable.metadata ?? {});
+                    const remoteStatus = ownerAllows(owners, "entity.status") && !blockedPaths.has("entity.status")
+                        ? writable.status ?? (existingEntity.status === "archived" ? "active" : undefined)
+                        : undefined;
+                    const updateInput = {};
+                    if (ownerAllows(owners, "entity.slug") && !blockedPaths.has("entity.slug") && existingEntity.slug !== writable.slug) {
+                        updateInput.slug = writable.slug;
+                    }
+                    if (hash(remoteMetadata) !== hash(existingEntity.metadata ?? {}))
+                        updateInput.metadata = remoteMetadata;
+                    if (remoteStatus !== undefined && !blockedPaths.has("entity.status") && remoteStatus !== existingEntity.status) {
+                        updateInput.status = remoteStatus;
+                        updateInput.isVisible = remoteStatus === "active";
                     }
-                    catch (error) {
-                        return PluginErr(error instanceof Error ? error.message : "Failed to create catalog entity.");
+                    const shouldUpdate = force
+                        ? Object.keys(updateInput).length > 0
+                        : remoteChanged || existingEntity.status === "archived";
+                    if (shouldUpdate) {
+                        converged += 1;
+                        if (Object.keys(updateInput).length > 0) {
+                            const updated = await this.catalog.update(entityMapping.entityId, updateInput, actor, CHANNEL_CONVERGENCE_CTX);
+                            if (!updated.ok) {
+                                failures.push({ externalId: item.externalId, error: updated.error.message });
+                                continue;
+                            }
+                            entityTouched = true;
+                        }
                     }
-                    isNew = true;
-                    imported += 1;
-                    entityTouched = true;
                 }
-            }
-            const ownershipBeforeSeed = await this.catalog.resolveFieldOwners(entityId, storeId);
-            const seedPaths = importedFieldPaths(item).filter((path) => !ownershipBeforeSeed.has(path));
-            const seeded = await this.catalog.seedImportedFieldOwnership(entityId, storeId, seedPaths);
-            if (!seeded.ok)
-                return PluginErr(seeded.error.message);
-            for (const path of seedPaths)
-                ownershipBeforeSeed.set(path, "store");
-            const owners = ownershipBeforeSeed;
-            const outboundEcho = entityMapping ? this.isOutboundEcho(entityMapping, item) : false;
-            const remoteChanged = entityMapping === undefined || entityMapping.syncHash !== remoteHash;
-            // An unchanged remote item writes nothing and advances no baseline:
-            // converging a stale replay would revert local edits to shared and
-            // unowned fields that the store never actually changed.
-            if (!force && !remoteChanged && existingEntity && existingEntity.status !== "archived") {
-                continue;
-            }
-            const shared = existingEntity
-                ? await this.detectSharedConflicts(entityId, storeId, existingEntity, entityMapping, item, owners, importedFieldPaths(item), remoteHash, outboundEcho ? { certifiedPaths: new Set(entityMapping?.outboundFieldPaths ?? []) } : undefined)
-                : { paths: [], conflicts: [] };
-            const persistedConflicts = await this.persistCatalogConflicts(orgId, shared.conflicts, requireUserId(actor));
-            if (!persistedConflicts.ok)
-                return persistedConflicts;
-            const owned = this.filterOwnedFields(item, owners);
-            const heldSharedPaths = [...new Set([...(entityMapping?.heldFieldPaths ?? []), ...shared.paths])];
-            // A newly held path revokes any force left from an earlier resolution of
-            // that same path: the force was the operator's answer to a question that
-            // has since been asked again, and it must not pre-empt the new one.
-            const survivingForcedPaths = (entityMapping?.forcedPushFieldPaths ?? []).filter((path) => !heldSharedPaths.includes(path));
-            const held = this.filterConflictingFields(owned.writable, heldSharedPaths);
-            const writable = held.writable;
-            const blockedPaths = new Set([...owned.skipped, ...heldSharedPaths]);
-            skipped.push(...owned.skipped.map((fieldPath) => ({ entityId, fieldPath })));
-            conflicts.push(...shared.conflicts.map(({ platformValue: _platformValue, storeValue: _storeValue, ...conflict }) => conflict));
-            for (const conflict of shared.conflicts) {
-                warnings.push(`Held shared field conflict for entity "${conflict.entityId}", store "${conflict.storeId}", field "${conflict.fieldPath}" (local ${conflict.localValueSummary}, remote ${conflict.remoteValueSummary}).`);
-            }
-            if (existingEntity && entityMapping) {
-                const remoteMetadata = mergeMetadata(existingEntity.metadata, writable.metadata ?? {});
-                const remoteStatus = ownerAllows(owners, "entity.status") && !blockedPaths.has("entity.status")
-                    ? writable.status ?? (existingEntity.status === "archived" ? "active" : undefined)
-                    : undefined;
-                const updateInput = {};
-                if (ownerAllows(owners, "entity.slug") && !blockedPaths.has("entity.slug") && existingEntity.slug !== writable.slug) {
-                    updateInput.slug = writable.slug;
+                const optionAxes = await this.upsertOptionAxes(entityId, writable, actor);
+                if (!optionAxes.ok)
+                    return optionAxes;
+                const attributes = await this.setCatalogAttributesIfWritable(entityId, writable, actor, blockedPaths, CHANNEL_CONVERGENCE_CTX);
+                if (!attributes.ok)
+                    return attributes;
+                const variantIds = await this.upsertVariants(orgId, storeId, entityId, writable, optionAxes.value.value, actor, warnings, !heldSharedPaths.includes("options") && owners.get("options") !== "platform", item);
+                if (!variantIds.ok)
+                    return variantIds;
+                const taxonomy = await this.applyTaxonomy(orgId, entityId, writable, actor, warnings);
+                if (!taxonomy.ok)
+                    return taxonomy;
+                const media = await this.applyMedia(orgId, entityId, writable, variantIds.value.value, actor, warnings, owners);
+                if (!media.ok)
+                    return media;
+                attributesCreated += attributes.value.created;
+                mediaImported += media.value.imported;
+                variantsGivenOptionValues += variantIds.value.repaired;
+                skipped.push(...media.value.skipped.map((fieldPath) => ({ entityId, fieldPath })));
+                entityTouched = entityTouched || optionAxes.value.changed || variantIds.value.changed || media.value.changed || attributes.value.changed;
+                if (entityTouched)
+                    entitiesTouched += 1;
+                if (entityTouched) {
+                    const revision = await this.catalog.recordEntityRevision(entityId, actor, "import");
+                    if (!revision.ok) {
+                        failures.push({ externalId: item.externalId, error: revision.error.message });
+                        continue;
+                    }
                 }
-                if (hash(remoteMetadata) !== hash(existingEntity.metadata ?? {}))
-                    updateInput.metadata = remoteMetadata;
-                if (remoteStatus !== undefined && !blockedPaths.has("entity.status") && remoteStatus !== existingEntity.status) {
-                    updateInput.status = remoteStatus;
-                    updateInput.isVisible = remoteStatus === "active";
+                const revisionMarkers = await this.catalog.repository.findRevisionMarkers(entityId);
+                const latestRevisionAt = revisionMarkers.at(-1)?.createdAt;
+                const lastSyncedAt = latestRevisionAt ?? entityMapping?.lastSyncedAt ?? new Date();
+                if (isNew) {
+                    await this.db.update(channelEntityMap).set({
+                        syncHash: remoteHash,
+                        lastSyncedAt,
+                        heldFieldPaths: heldSharedPaths,
+                        forcedPushFieldPaths: survivingForcedPaths,
+                    }).where(and(eq(channelEntityMap.organizationId, orgId), eq(channelEntityMap.storeId, storeId), eq(channelEntityMap.kind, "entity"), eq(channelEntityMap.externalId, item.externalId), eq(channelEntityMap.entityId, entityId)));
                 }
-                const shouldUpdate = force
-                    ? Object.keys(updateInput).length > 0
-                    : remoteChanged || existingEntity.status === "archived";
-                if (shouldUpdate) {
-                    converged += 1;
-                    if (Object.keys(updateInput).length > 0) {
-                        const updated = await this.catalog.update(entityMapping.entityId, updateInput, actor, CHANNEL_CONVERGENCE_CTX);
-                        if (!updated.ok)
-                            return PluginErr(updated.error.message);
-                        entityTouched = true;
-                    }
+                else if (adoptedOrphan) {
+                    await this.db.insert(channelEntityMap).values({
+                        organizationId: orgId,
+                        storeId,
+                        kind: "entity",
+                        externalId: item.externalId,
+                        entityId,
+                        syncHash: remoteHash,
+                        lastSyncedAt,
+                        heldFieldPaths: heldSharedPaths,
+                        forcedPushFieldPaths: survivingForcedPaths,
+                    });
                 }
+                else if (entityMapping) {
+                    await this.db.update(channelEntityMap).set({
+                        syncHash: remoteHash,
+                        lastSyncedAt,
+                        heldFieldPaths: heldSharedPaths,
+                        forcedPushFieldPaths: survivingForcedPaths,
+                    }).where(eq(channelEntityMap.id, entityMapping.id));
+                }
+                await this.db.update(channelEntityMap).set({ lastSyncedAt }).where(and(eq(channelEntityMap.organizationId, orgId), eq(channelEntityMap.storeId, storeId), eq(channelEntityMap.entityId, entityId), eq(channelEntityMap.kind, "variant")));
             }
-            const optionAxes = await this.upsertOptionAxes(entityId, writable, actor);
-            if (!optionAxes.ok)
-                return optionAxes;
-            const attributes = await this.setCatalogAttributesIfWritable(entityId, writable, actor, blockedPaths, CHANNEL_CONVERGENCE_CTX);
-            if (!attributes.ok)
-                return attributes;
-            const variantIds = await this.upsertVariants(orgId, storeId, entityId, writable, optionAxes.value.value, actor, warnings, !heldSharedPaths.includes("options") && owners.get("options") !== "platform", item);
-            if (!variantIds.ok)
-                return variantIds;
-            const taxonomy = await this.applyTaxonomy(orgId, entityId, writable, actor, warnings);
-            if (!taxonomy.ok)
-                return taxonomy;
-            const media = await this.applyMedia(orgId, entityId, writable, variantIds.value.value, actor, warnings, owners);
-            if (!media.ok)
-                return media;
-            attributesCreated += attributes.value.created;
-            mediaImported += media.value.imported;
-            variantsGivenOptionValues += variantIds.value.repaired;
-            skipped.push(...media.value.skipped.map((fieldPath) => ({ entityId, fieldPath })));
-            entityTouched = entityTouched || optionAxes.value.changed || variantIds.value.changed || media.value.changed || attributes.value.changed;
-            if (entityTouched)
-                entitiesTouched += 1;
-            if (entityTouched) {
-                const revision = await this.catalog.recordEntityRevision(entityId, actor, "import");
-                if (!revision.ok)
-                    return PluginErr(revision.error.message);
-            }
-            const revisionMarkers = await this.catalog.repository.findRevisionMarkers(entityId);
-            const latestRevisionAt = revisionMarkers.at(-1)?.createdAt;
-            const lastSyncedAt = latestRevisionAt ?? entityMapping?.lastSyncedAt ?? new Date();
-            if (isNew) {
-                await this.db.update(channelEntityMap).set({
-                    syncHash: remoteHash,
-                    lastSyncedAt,
-                    heldFieldPaths: heldSharedPaths,
-                    forcedPushFieldPaths: survivingForcedPaths,
-                }).where(and(eq(channelEntityMap.organizationId, orgId), eq(channelEntityMap.storeId, storeId), eq(channelEntityMap.kind, "entity"), eq(channelEntityMap.externalId, item.externalId), eq(channelEntityMap.entityId, entityId)));
-            }
-            else if (adoptedOrphan) {
-                await this.db.insert(channelEntityMap).values({
-                    organizationId: orgId,
-                    storeId,
-                    kind: "entity",
-                    externalId: item.externalId,
-                    entityId,
-                    syncHash: remoteHash,
-                    lastSyncedAt,
-                    heldFieldPaths: heldSharedPaths,
-                    forcedPushFieldPaths: survivingForcedPaths,
-                });
-            }
-            else if (entityMapping) {
-                await this.db.update(channelEntityMap).set({
-                    syncHash: remoteHash,
-                    lastSyncedAt,
-                    heldFieldPaths: heldSharedPaths,
-                    forcedPushFieldPaths: survivingForcedPaths,
-                }).where(eq(channelEntityMap.id, entityMapping.id));
+            catch (error) {
+                // Anything the stages throw rather than returning. Same disposition: record it against the
+                // item and carry on, so an unforeseen throw costs one product and not the remaining page.
+                failures.push({ externalId: item.externalId, error: error instanceof Error ? error.message : String(error) });
+                continue;
             }
-            await this.db.update(channelEntityMap).set({ lastSyncedAt }).where(and(eq(channelEntityMap.organizationId, orgId), eq(channelEntityMap.storeId, storeId), eq(channelEntityMap.entityId, entityId), eq(channelEntityMap.kind, "variant")));
         }
         return Ok({
             imported,
@@ -2284,6 +2307,7 @@ export class ChannelConnectorService {
             skipped,
             conflicts,
             warnings,
+            failures,
         });
     }
     async reconcile(orgId, storeId, actor) {