ghost 6.53.0 → 6.54.0

package/core/server/services/url/lazy-url-service.js

@@ -3,9 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LazyUrlService = void 0;
 const debug = require('@tryghost/debug')('services:url:lazy');
 const errors = require('@tryghost/errors');
-const localUtils = require('../../../shared/url-utils');
+const localUtils = require('../../../shared/url-utils').default;
 const { matchPermalink, toLookupParams } = require('./permalink-matcher');
 const { buildFilter, filterMatches, routerTypeOf } = require('./router-filter');
+const urlConfig = require('./config');
 // Per-resource-type base filters, mirroring eager's resource-fetch filters
 // (`modelOptions.filter` in services/url/config.js). Deliberately duplicated
 // rather than imported: lazy is meant to replace eager, at which point eager's
@@ -32,6 +33,26 @@ function buildBaseFilters() {
     }
     return baseFilters;
 }
+// Columns eager drops from its in-memory URL cache (the `exclude` lists in
+// services/url/config.js). Eager evaluates a router's collection filter against
+// that reduced cached record, so an excluded column reads as absent — NQL then
+// treats it as null. Lazy loads full records and would see the real value, so
+// to preserve eager's behaviour it strips these columns before evaluating
+// router filters (and neither requires nor force-loads them). Keyed by
+// resourceType ('posts'/'pages'/'tags'). Read from eager's config directly so
+// the two can't drift; when eager is retired this derives from whatever
+// replaces it. The base filter is unaffected — it runs against the full record.
+function buildExcludedFilterFields() {
+    const excluded = new Map();
+    for (const entry of urlConfig) {
+        const exclude = entry?.modelOptions?.exclude;
+        if (Array.isArray(exclude)) {
+            excluded.set(entry.type, new Set(exclude));
+        }
+    }
+    return excluded;
+}
+const EMPTY_FIELD_SET = new Set();
 // Relation roots are loaded via getRequiredRelations (as withRelated), not as
 // scalar columns; `page`/`type` are the router-type discriminator, always set
 // on the resource. Everything else a router filter references is a scalar
@@ -76,6 +97,7 @@ class LazyUrlService {
     routerConfigs;
     requiredRelations;
     baseFilters;
+    excludedFilterFields;
     constructor({ urlUtils = localUtils, findResource }) {
         if (typeof findResource !== 'function') {
             throw new errors.IncorrectUsageError({
@@ -87,6 +109,7 @@ class LazyUrlService {
         this.routerConfigs = [];
         this.requiredRelations = null;
         this.baseFilters = buildBaseFilters();
+        this.excludedFilterFields = buildExcludedFilterFields();
     }
     onRouterAddedType(identifier, filter, resourceType, permalink) {
         debug('onRouterAddedType', identifier, resourceType, permalink, filter);
@@ -140,6 +163,7 @@ class LazyUrlService {
     // by getRequiredRelations; eager needs none of this (it looks URLs up by id).
     getRequiredFields(routerType) {
         const fields = new Set();
+        const excluded = this._excludedFilterFieldsFor(routerType);
         const base = this.baseFilters.get(routerType);
         if (base) {
             base.fields.forEach(field => fields.add(field));
@@ -168,7 +192,14 @@ class LazyUrlService {
                     fields.add(computed);
                 }
             }
-            filterScalarFields(config.filter).forEach(field => fields.add(field));
+            // Skip columns eager drops from its cache: it never force-loads them
+            // and evaluates their filters against an absent value, so lazy must
+            // not require them either (see buildExcludedFilterFields).
+            filterScalarFields(config.filter).forEach((field) => {
+                if (!excluded.has(field)) {
+                    fields.add(field);
+                }
+            });
         }
         return [...fields];
     }
@@ -181,6 +212,10 @@ class LazyUrlService {
             return this._formatNotFound(options);
         }
         const record = this._recordForFilter(resource);
+        // The router (collection) filter is evaluated against eager's reduced
+        // column set; the base filter keeps the full record (it reads status /
+        // type / visibility, which eager applies at query time, not in cache).
+        const filterRecord = this._recordForRouterFilter(record, routerType);
         // Eager only builds URLs for resources that pass the per-type base
         // filter (e.g. visibility:public tags, status:published posts), so a
         // resource failing it has no URL there and must 404 here too. Checked
@@ -197,7 +232,7 @@ class LazyUrlService {
                 continue;
             }
             this._assertNotThin(config, resource, routerType);
-            if (filterMatches(config.compiledFilter, record)) {
+            if (filterMatches(config.compiledFilter, filterRecord)) {
                 const path = this.urlUtils.replacePermalink(config.permalink, resource);
                 return this._formatPath(path, options);
             }
@@ -218,9 +253,10 @@ class LazyUrlService {
         if (!this._baseFilterMatches(routerType, record)) {
             return false;
         }
+        const filterRecord = this._recordForRouterFilter(record, routerType);
         // Ownership is exclusive: only the first matching router of the type
         // owns the resource, matching eager's reservation.
-        const owner = this.routerConfigs.find(c => c.resourceType === routerType && filterMatches(c.compiledFilter, record));
+        const owner = this.routerConfigs.find(c => c.resourceType === routerType && filterMatches(c.compiledFilter, filterRecord));
         return !!owner && owner.identifier === routerIdentifier;
     }
     async resolveUrl(urlPath) {
@@ -252,7 +288,7 @@ class LazyUrlService {
             // The base filter is enforced upstream by findResource's query
             // scoping (visibility:public / status:published), so only the
             // router filter needs re-checking here.
-            const record = this._recordForFilter(resource);
+            const record = this._recordForRouterFilter(this._recordForFilter(resource), config.resourceType);
             if (!filterMatches(config.compiledFilter, record)) {
                 continue;
             }
@@ -321,6 +357,27 @@ class LazyUrlService {
         const dbType = ROUTER_TYPE_TO_DB_TYPE[record.type];
         return dbType ? { ...record, type: dbType } : record;
     }
+    _excludedFilterFieldsFor(routerType) {
+        return this.excludedFilterFields.get(routerType) ?? EMPTY_FIELD_SET;
+    }
+    // Strips the columns eager drops from its cache so a router/collection
+    // filter is evaluated against the same reduced shape eager uses — an
+    // excluded column reads as absent (→ null in NQL) rather than its real
+    // value. Only affects filters that reference an excluded column; every
+    // other filter sees an identical record.
+    _recordForRouterFilter(record, routerType) {
+        const excluded = this._excludedFilterFieldsFor(routerType);
+        if (excluded.size === 0) {
+            return record;
+        }
+        const stripped = {};
+        for (const key of Object.keys(record)) {
+            if (!excluded.has(key)) {
+                stripped[key] = record[key];
+            }
+        }
+        return stripped;
+    }
     _formatPath(path, options) {
         if (options.absolute) {
             return this.urlUtils.createUrl(path, options.absolute);
@@ -363,8 +420,11 @@ class LazyUrlService {
         if (/\bprimary_author\b/.test(config.filter) && r.primary_author === undefined) {
             missing.push('primary_author');
         }
+        // Columns eager drops from its cache are never required — its filters
+        // match them as absent, so a resource lacking one is not thin here.
+        const excluded = this._excludedFilterFieldsFor(routerType);
         for (const field of filterScalarFields(config.filter)) {
-            if (r[field] === undefined) {
+            if (!excluded.has(field) && r[field] === undefined) {
                 missing.push(field);
             }
         }

package/core/server/services/url/lazy-url-service.ts

@@ -1,8 +1,9 @@
 const debug = require('@tryghost/debug')('services:url:lazy');
 const errors = require('@tryghost/errors');
-const localUtils = require('../../../shared/url-utils');
+const localUtils = require('../../../shared/url-utils').default;
 const {matchPermalink, toLookupParams} = require('./permalink-matcher');
 const {buildFilter, filterMatches, routerTypeOf} = require('./router-filter');
+const urlConfig = require('./config');
 
 import type {Resource, UrlOptions, LazyUrlServiceBackend} from './url-service-facade';
 import type {CompiledFilter} from './router-filter';
@@ -57,6 +58,28 @@ function buildBaseFilters(): Map<string, BaseFilter> {
     return baseFilters;
 }
 
+// Columns eager drops from its in-memory URL cache (the `exclude` lists in
+// services/url/config.js). Eager evaluates a router's collection filter against
+// that reduced cached record, so an excluded column reads as absent — NQL then
+// treats it as null. Lazy loads full records and would see the real value, so
+// to preserve eager's behaviour it strips these columns before evaluating
+// router filters (and neither requires nor force-loads them). Keyed by
+// resourceType ('posts'/'pages'/'tags'). Read from eager's config directly so
+// the two can't drift; when eager is retired this derives from whatever
+// replaces it. The base filter is unaffected — it runs against the full record.
+function buildExcludedFilterFields(): Map<string, Set<string>> {
+    const excluded = new Map<string, Set<string>>();
+    for (const entry of urlConfig) {
+        const exclude = entry?.modelOptions?.exclude;
+        if (Array.isArray(exclude)) {
+            excluded.set(entry.type, new Set(exclude));
+        }
+    }
+    return excluded;
+}
+
+const EMPTY_FIELD_SET: ReadonlySet<string> = new Set();
+
 // Relation roots are loaded via getRequiredRelations (as withRelated), not as
 // scalar columns; `page`/`type` are the router-type discriminator, always set
 // on the resource. Everything else a router filter references is a scalar
@@ -109,6 +132,7 @@ export class LazyUrlService implements LazyUrlServiceBackend {
     private routerConfigs: RouterConfig[];
     private requiredRelations: string[] | null;
     private baseFilters: Map<string, BaseFilter>;
+    private excludedFilterFields: Map<string, Set<string>>;
 
     constructor({urlUtils = localUtils, findResource}: LazyUrlServiceDeps) {
         if (typeof findResource !== 'function') {
@@ -121,6 +145,7 @@ export class LazyUrlService implements LazyUrlServiceBackend {
         this.routerConfigs = [];
         this.requiredRelations = null;
         this.baseFilters = buildBaseFilters();
+        this.excludedFilterFields = buildExcludedFilterFields();
     }
 
     onRouterAddedType(identifier: string, filter: string | null, resourceType: string, permalink: string): void {
@@ -179,6 +204,7 @@ export class LazyUrlService implements LazyUrlServiceBackend {
     // by getRequiredRelations; eager needs none of this (it looks URLs up by id).
     getRequiredFields(routerType: string): string[] {
         const fields = new Set<string>();
+        const excluded = this._excludedFilterFieldsFor(routerType);
         const base = this.baseFilters.get(routerType);
         if (base) {
             base.fields.forEach(field => fields.add(field));
@@ -207,7 +233,14 @@ export class LazyUrlService implements LazyUrlServiceBackend {
                     fields.add(computed);
                 }
             }
-            filterScalarFields(config.filter).forEach(field => fields.add(field));
+            // Skip columns eager drops from its cache: it never force-loads them
+            // and evaluates their filters against an absent value, so lazy must
+            // not require them either (see buildExcludedFilterFields).
+            filterScalarFields(config.filter).forEach((field) => {
+                if (!excluded.has(field)) {
+                    fields.add(field);
+                }
+            });
         }
         return [...fields];
     }
@@ -223,6 +256,10 @@ export class LazyUrlService implements LazyUrlServiceBackend {
         }
 
         const record = this._recordForFilter(resource);
+        // The router (collection) filter is evaluated against eager's reduced
+        // column set; the base filter keeps the full record (it reads status /
+        // type / visibility, which eager applies at query time, not in cache).
+        const filterRecord = this._recordForRouterFilter(record, routerType);
 
         // Eager only builds URLs for resources that pass the per-type base
         // filter (e.g. visibility:public tags, status:published posts), so a
@@ -241,7 +278,7 @@ export class LazyUrlService implements LazyUrlServiceBackend {
                 continue;
             }
             this._assertNotThin(config, resource, routerType);
-            if (filterMatches(config.compiledFilter, record)) {
+            if (filterMatches(config.compiledFilter, filterRecord)) {
                 const path = this.urlUtils.replacePermalink(config.permalink, resource);
                 return this._formatPath(path, options);
             }
@@ -263,10 +300,11 @@ export class LazyUrlService implements LazyUrlServiceBackend {
         if (!this._baseFilterMatches(routerType, record)) {
             return false;
         }
+        const filterRecord = this._recordForRouterFilter(record, routerType);
         // Ownership is exclusive: only the first matching router of the type
         // owns the resource, matching eager's reservation.
         const owner = this.routerConfigs.find(
-            c => c.resourceType === routerType && filterMatches(c.compiledFilter, record)
+            c => c.resourceType === routerType && filterMatches(c.compiledFilter, filterRecord)
         );
         return !!owner && owner.identifier === routerIdentifier;
     }
@@ -299,7 +337,10 @@ export class LazyUrlService implements LazyUrlServiceBackend {
             // The base filter is enforced upstream by findResource's query
             // scoping (visibility:public / status:published), so only the
             // router filter needs re-checking here.
-            const record = this._recordForFilter(resource as Resource);
+            const record = this._recordForRouterFilter(
+                this._recordForFilter(resource as Resource),
+                config.resourceType
+            );
             if (!filterMatches(config.compiledFilter, record)) {
                 continue;
             }
@@ -374,6 +415,29 @@ export class LazyUrlService implements LazyUrlServiceBackend {
         return dbType ? {...record, type: dbType} : record;
     }
 
+    private _excludedFilterFieldsFor(routerType: string): ReadonlySet<string> {
+        return this.excludedFilterFields.get(routerType) ?? EMPTY_FIELD_SET;
+    }
+
+    // Strips the columns eager drops from its cache so a router/collection
+    // filter is evaluated against the same reduced shape eager uses — an
+    // excluded column reads as absent (→ null in NQL) rather than its real
+    // value. Only affects filters that reference an excluded column; every
+    // other filter sees an identical record.
+    private _recordForRouterFilter(record: Record<string, unknown>, routerType: string): Record<string, unknown> {
+        const excluded = this._excludedFilterFieldsFor(routerType);
+        if (excluded.size === 0) {
+            return record;
+        }
+        const stripped: Record<string, unknown> = {};
+        for (const key of Object.keys(record)) {
+            if (!excluded.has(key)) {
+                stripped[key] = record[key];
+            }
+        }
+        return stripped;
+    }
+
     private _formatPath(path: string, options: UrlOptions): string {
         if (options.absolute) {
             return this.urlUtils.createUrl(path, options.absolute);
@@ -418,8 +482,11 @@ export class LazyUrlService implements LazyUrlServiceBackend {
         if (/\bprimary_author\b/.test(config.filter) && r.primary_author === undefined) {
             missing.push('primary_author');
         }
+        // Columns eager drops from its cache are never required — its filters
+        // match them as absent, so a resource lacking one is not thin here.
+        const excluded = this._excludedFilterFieldsFor(routerType);
         for (const field of filterScalarFields(config.filter)) {
-            if (r[field] === undefined) {
+            if (!excluded.has(field) && r[field] === undefined) {
                 missing.push(field);
             }
         }

package/core/server/services/url/url-generator.js

@@ -1,6 +1,6 @@
 const nql = require('@tryghost/nql');
 const debug = require('@tryghost/debug')('services:url:generator');
-const localUtils = require('../../../shared/url-utils');
+const localUtils = require('../../../shared/url-utils').default;
 
 // @TODO: merge with filter plugin
 const EXPANSIONS = [{

package/core/server/services/url/url-service-facade.js

@@ -50,7 +50,10 @@ class UrlServiceFacade {
         const url = this.urlService.getUrlByResourceId(resource.id, options);
         if (this.isComparing() && !options?.skipComparison) {
             const context = this._compareContext(resource);
-            setImmediate(() => this._compare('getUrlForResource', url, () => this.lazyUrlService.getUrlForResource(resource, options), context));
+            // Snapshot: callers mutate the resource's nested objects in place
+            // after this returns, but the comparison runs later via setImmediate.
+            const snapshot = _.cloneDeep(resource);
+            setImmediate(() => this._compare('getUrlForResource', url, () => this.lazyUrlService.getUrlForResource(snapshot, options), context));
         }
         return url;
     }
@@ -117,7 +120,9 @@ class UrlServiceFacade {
         const owns = this.urlService.owns(routerIdentifier, resource.id);
         if (this.isComparing()) {
             const context = this._compareContext(resource, { routerIdentifier });
-            setImmediate(() => this._compare('ownsResource', owns, () => this.lazyUrlService.ownsResource(routerIdentifier, resource), context));
+            // Snapshot, as in getUrlForResource.
+            const snapshot = _.cloneDeep(resource);
+            setImmediate(() => this._compare('ownsResource', owns, () => this.lazyUrlService.ownsResource(routerIdentifier, snapshot), context));
         }
         return owns;
     }
@@ -133,6 +138,7 @@ class UrlServiceFacade {
         return {
             type: resource.type,
             id: resource.id,
+            status: resource.status,
             resourceKeys: Object.keys(resource),
             caller: caller.stack,
             ...extra
@@ -157,7 +163,9 @@ class UrlServiceFacade {
         if (this.isComparing()) {
             // Fire-and-forget: don't await lazy so the reverse lookup adds no
             // latency for its callers; the lazy DB read runs in the background.
-            void this._compareAsync('resolveUrl', eagerResult, () => this.lazyUrlService.resolveUrl(urlPath), { path: urlPath }, (a, b) => _.isEqual(a, b));
+            // Snapshot the eager result, as in getUrlForResource.
+            const eagerSnapshot = _.cloneDeep(eagerResult);
+            void this._compareAsync('resolveUrl', eagerSnapshot, () => this.lazyUrlService.resolveUrl(urlPath), { path: urlPath }, (a, b) => this._resolvesToSameResource(a, b));
         }
         return eagerResult;
     }
@@ -250,8 +258,65 @@ class UrlServiceFacade {
         }
         this._reportMismatch(method, eagerValue, lazyValue, context, isEqual);
     }
+    _isNotFound(value) {
+        return typeof value === 'string' && value.endsWith('/404/');
+    }
+    // resolveUrl's contract is which resource a path maps to, not the exact
+    // serialized record. Eager (raw-knex) and lazy (model.toJSON) shape the same
+    // DB row differently — lazy carries a `parent` key eager omits, eager keeps
+    // __GHOST_URL__ placeholders lazy expands, timestamps differ in precision —
+    // so comparing whole records reports the same resolved resource as a
+    // mismatch. Compare resolved identity instead.
+    _resolvesToSameResource(a, b) {
+        if (a === null || b === null) {
+            return a === b;
+        }
+        const ra = a;
+        const rb = b;
+        return ra.id === rb.id && ra.type === rb.type;
+    }
+    // Divergences that are not lazy regressions, so logging them only buries
+    // the ones that are. Each branch is a class confirmed from production
+    // compare data.
+    _isExpectedDivergence(method, eagerValue, lazyValue, context) {
+        // Eager leaves tags/authors with no published posts out of its URL map
+        // (the shouldHavePosts gate) so they resolve to /404/, while lazy has no
+        // cheap way to run that check and returns the real URL. Eager cache
+        // staleness (a tag gaining its first post after boot) looks the same.
+        // Whether to keep lazy's behaviour is still open, but either way it is
+        // not a lazy bug, so exclude it to surface the divergences that are.
+        if (method === 'getUrlForResource'
+            && (context.type === 'tags' || context.type === 'authors')
+            && this._isNotFound(eagerValue) && !this._isNotFound(lazyValue)) {
+            return true;
+        }
+        // A site's owner starts with the default `ghost-user` slug and is
+        // renamed during setup. The rename emits no event the eager cache
+        // consumes, so eager serves /author/ghost-user/ until the next boot
+        // while lazy has the real slug from the database.
+        if (method === 'getUrlForResource'
+            && context.type === 'authors'
+            && typeof eagerValue === 'string' && eagerValue.endsWith('/author/ghost-user/')
+            && !this._isNotFound(lazyValue)) {
+            return true;
+        }
+        // lazy returns /404/ where eager serves a real URL: eager cached a
+        // resource that is no longer routable (unpublished or deleted since,
+        // with no event to evict it). Suppress only when the resource is
+        // provably not published — a published resource lazy refuses to route
+        // is a real lazy bug, so that keeps logging.
+        if (method === 'getUrlForResource'
+            && this._isNotFound(lazyValue) && !this._isNotFound(eagerValue)
+            && typeof context.status === 'string' && context.status !== 'published') {
+            return true;
+        }
+        return false;
+    }
     _reportMismatch(method, eagerValue, lazyValue, context, isEqual) {
         if (!isEqual(eagerValue, lazyValue)) {
+            if (this._isExpectedDivergence(method, eagerValue, lazyValue, context)) {
+                return;
+            }
             const { caller, ...details } = context;
             const report = new errors.InternalServerError({
                 message: 'URL service parity mismatch',

package/core/server/services/url/url-service-facade.ts

@@ -139,8 +139,11 @@ export class UrlServiceFacade {
         const url = this.urlService.getUrlByResourceId(resource.id, options);
         if (this.isComparing() && !options?.skipComparison) {
             const context = this._compareContext(resource);
+            // Snapshot: callers mutate the resource's nested objects in place
+            // after this returns, but the comparison runs later via setImmediate.
+            const snapshot = _.cloneDeep(resource);
             setImmediate(() => this._compare('getUrlForResource', url,
-                () => this.lazyUrlService!.getUrlForResource(resource, options),
+                () => this.lazyUrlService!.getUrlForResource(snapshot, options),
                 context));
         }
         return url;
@@ -218,8 +221,10 @@ export class UrlServiceFacade {
         const owns = this.urlService.owns(routerIdentifier, resource.id);
         if (this.isComparing()) {
             const context = this._compareContext(resource, {routerIdentifier});
+            // Snapshot, as in getUrlForResource.
+            const snapshot = _.cloneDeep(resource);
             setImmediate(() => this._compare('ownsResource', owns,
-                () => this.lazyUrlService!.ownsResource(routerIdentifier, resource),
+                () => this.lazyUrlService!.ownsResource(routerIdentifier, snapshot),
                 context));
         }
         return owns;
@@ -237,6 +242,7 @@ export class UrlServiceFacade {
         return {
             type: resource.type,
             id: resource.id,
+            status: (resource as Record<string, unknown>).status,
             resourceKeys: Object.keys(resource),
             caller: caller.stack,
             ...extra
@@ -262,10 +268,12 @@ export class UrlServiceFacade {
         if (this.isComparing()) {
             // Fire-and-forget: don't await lazy so the reverse lookup adds no
             // latency for its callers; the lazy DB read runs in the background.
-            void this._compareAsync('resolveUrl', eagerResult,
+            // Snapshot the eager result, as in getUrlForResource.
+            const eagerSnapshot = _.cloneDeep(eagerResult);
+            void this._compareAsync('resolveUrl', eagerSnapshot,
                 () => this.lazyUrlService!.resolveUrl(urlPath),
                 {path: urlPath},
-                (a, b) => _.isEqual(a, b));
+                (a, b) => this._resolvesToSameResource(a, b));
         }
         return eagerResult;
     }
@@ -377,6 +385,70 @@ export class UrlServiceFacade {
         this._reportMismatch(method, eagerValue, lazyValue, context, isEqual);
     }
 
+    private _isNotFound(value: unknown): boolean {
+        return typeof value === 'string' && value.endsWith('/404/');
+    }
+
+    // resolveUrl's contract is which resource a path maps to, not the exact
+    // serialized record. Eager (raw-knex) and lazy (model.toJSON) shape the same
+    // DB row differently — lazy carries a `parent` key eager omits, eager keeps
+    // __GHOST_URL__ placeholders lazy expands, timestamps differ in precision —
+    // so comparing whole records reports the same resolved resource as a
+    // mismatch. Compare resolved identity instead.
+    private _resolvesToSameResource(a: unknown, b: unknown): boolean {
+        if (a === null || b === null) {
+            return a === b;
+        }
+        const ra = a as Resource;
+        const rb = b as Resource;
+        return ra.id === rb.id && ra.type === rb.type;
+    }
+
+    // Divergences that are not lazy regressions, so logging them only buries
+    // the ones that are. Each branch is a class confirmed from production
+    // compare data.
+    private _isExpectedDivergence(
+        method: string,
+        eagerValue: unknown,
+        lazyValue: unknown,
+        context: Record<string, unknown>
+    ): boolean {
+        // Eager leaves tags/authors with no published posts out of its URL map
+        // (the shouldHavePosts gate) so they resolve to /404/, while lazy has no
+        // cheap way to run that check and returns the real URL. Eager cache
+        // staleness (a tag gaining its first post after boot) looks the same.
+        // Whether to keep lazy's behaviour is still open, but either way it is
+        // not a lazy bug, so exclude it to surface the divergences that are.
+        if (method === 'getUrlForResource'
+            && (context.type === 'tags' || context.type === 'authors')
+            && this._isNotFound(eagerValue) && !this._isNotFound(lazyValue)) {
+            return true;
+        }
+
+        // A site's owner starts with the default `ghost-user` slug and is
+        // renamed during setup. The rename emits no event the eager cache
+        // consumes, so eager serves /author/ghost-user/ until the next boot
+        // while lazy has the real slug from the database.
+        if (method === 'getUrlForResource'
+            && context.type === 'authors'
+            && typeof eagerValue === 'string' && eagerValue.endsWith('/author/ghost-user/')
+            && !this._isNotFound(lazyValue)) {
+            return true;
+        }
+
+        // lazy returns /404/ where eager serves a real URL: eager cached a
+        // resource that is no longer routable (unpublished or deleted since,
+        // with no event to evict it). Suppress only when the resource is
+        // provably not published — a published resource lazy refuses to route
+        // is a real lazy bug, so that keeps logging.
+        if (method === 'getUrlForResource'
+            && this._isNotFound(lazyValue) && !this._isNotFound(eagerValue)
+            && typeof context.status === 'string' && context.status !== 'published') {
+            return true;
+        }
+        return false;
+    }
+
     private _reportMismatch(
         method: string,
         eagerValue: unknown,
@@ -385,6 +457,9 @@ export class UrlServiceFacade {
         isEqual: (a: unknown, b: unknown) => boolean
     ): void {
         if (!isEqual(eagerValue, lazyValue)) {
+            if (this._isExpectedDivergence(method, eagerValue, lazyValue, context)) {
+                return;
+            }
             const {caller, ...details} = context;
             const report = new errors.InternalServerError({
                 message: 'URL service parity mismatch',

package/core/server/services/url/url-service.js

@@ -8,7 +8,7 @@ const UrlGenerator = require('./url-generator');
 const Queue = require('./queue');
 const Urls = require('./urls');
 const Resources = require('./resources');
-const urlUtils = require('../../../shared/url-utils');
+const urlUtils = require('../../../shared/url-utils').default;
 const resourcesConfig = require('./config');
 
 /**

package/core/server/services/url/urls.js

@@ -1,5 +1,5 @@
 const debug = require('@tryghost/debug')('services:url:urls');
-const urlUtils = require('../../../shared/url-utils');
+const urlUtils = require('../../../shared/url-utils').default;
 const logging = require('@tryghost/logging');
 const errors = require('@tryghost/errors');
 

package/core/server/services/webhooks/index.js

@@ -1,5 +1,22 @@
+// Composition root for the webhook dispatch pipeline: builds the
+// serialize → payload → trigger chain and registers the model-event
+// listeners. Requires are deferred until listen() runs so the model layer
+// isn't loaded before boot wires it.
 module.exports = {
-    get listen() {
-        return require('./listen');
+    listen() {
+        const models = require('../../models');
+        const limitService = require('../../services/limits');
+        const events = require('../../lib/common/events');
+        const urlService = require('../url').facade;
+        const createSerialize = require('./serialize');
+        const createPayload = require('./payload');
+        const WebhookTrigger = require('./webhook-trigger');
+        const registerListeners = require('./listen');
+
+        const serialize = createSerialize({urlService});
+        const payload = createPayload({serialize});
+        const trigger = new WebhookTrigger({models, payload, limitService});
+
+        registerListeners({events, trigger});
     }
 };

package/core/server/services/webhooks/listen.js

@@ -1,11 +1,4 @@
 const _ = require('lodash');
-const limitService = require('../../services/limits');
-const WebhookTrigger = require('./webhook-trigger');
-const models = require('../../models');
-const payload = require('./payload');
-
-// The webhook system is fundamentally built on top of our model event system
-const events = require('../../lib/common/events');
 
 const WEBHOOKS = [
     'site.changed',
@@ -44,8 +37,10 @@ const WEBHOOKS = [
     'page.tag.detached'
 ];
 
-const listen = async () => {
-    const webhookTrigger = new WebhookTrigger({models, payload, limitService});
+// Registers the webhook dispatch listeners on the model event system. The
+// trigger is built by the composition root (index.js) and injected here so
+// this module owns only the event-to-trigger wiring.
+const registerListeners = ({events, trigger}) => {
     _.each(WEBHOOKS, (event) => {
         // @NOTE: The early exit makes sure the listeners are only registered once.
         //        During testing the "events" instance is kept around with all the
@@ -62,9 +57,9 @@ const listen = async () => {
                 return;
             }
 
-            webhookTrigger.trigger(event, model);
+            trigger.trigger(event, model);
         });
     });
 };
 
-module.exports = listen;
+module.exports = registerListeners;

package/core/server/services/webhooks/payload.js

@@ -1,6 +1,4 @@
-const serialize = require('./serialize');
-
-module.exports = (event, model) => {
+module.exports = ({serialize}) => (event, model) => {
     const payload = {};
 
     if (model) {