@arkebcacy/beacon-cli-temp 0.1.1

package/src/dto/entry/BeaconReplacer.ts

@@ -0,0 +1,37 @@
+import type { ContentType } from '#cli/cs/content-types/Types.js';
+import type { ReferencePath } from '#cli/cs/entries/Types.js';
+import mapItemPathToAsset from './beaconReplacer/lib/mapItemPathToAsset.js';
+import process from './beaconReplacer/lib/process.js';
+import processAsset from './beaconReplacer/lib/processAsset.js';
+import processJsonRteAsset from './beaconReplacer/lib/processJsonRteAsset.js';
+import processObject from './beaconReplacer/lib/processObject.js';
+import processReference from './beaconReplacer/lib/processReference.js';
+import processValue from './beaconReplacer/lib/processValue.js';
+import stripTaxonomies from './beaconReplacer/lib/stripTaxonomies.js';
+import type MinimalCtx from './lib/MinimalCtx.js';
+
+export default class BeaconReplacer {
+	public readonly process: typeof process;
+	protected refPath: ReferencePath | undefined;
+	protected readonly mapItemPathToAsset: typeof mapItemPathToAsset;
+	protected readonly processAsset: typeof processAsset;
+	protected readonly processJsonRteAsset: typeof processJsonRteAsset;
+	protected readonly processObject: typeof processObject;
+	protected readonly processReference: typeof processReference;
+	protected readonly processValue: typeof processValue;
+	protected readonly stripTaxonomies: typeof stripTaxonomies;
+
+	public constructor(
+		protected readonly ctx: MinimalCtx,
+		protected readonly contentType: ContentType,
+	) {
+		this.mapItemPathToAsset = mapItemPathToAsset.bind(this);
+		this.process = process.bind(this);
+		this.processAsset = processAsset.bind(this);
+		this.processJsonRteAsset = processJsonRteAsset.bind(this);
+		this.processObject = processObject.bind(this);
+		this.processReference = processReference.bind(this);
+		this.processValue = processValue.bind(this);
+		this.stripTaxonomies = stripTaxonomies.bind(this);
+	}
+}

package/src/dto/entry/beaconReplacer/lib/mapItemPathToAsset.ts

@@ -0,0 +1,20 @@
+import resolveRawAssetItem from '#cli/cs/assets/lib/resolveRawAssetItem.js';
+import { isRawAsset } from '#cli/cs/assets/Types.js';
+import type BeaconReplacer from '../../BeaconReplacer.js';
+
+export default function mapItemPathToAsset(
+	this: BeaconReplacer,
+	itemPath: string,
+) {
+	const result = resolveRawAssetItem(this.ctx.cs.assets.byParentUid, itemPath);
+
+	if (!result) {
+		throw new Error(`Could not find asset ${itemPath}.`);
+	}
+
+	if (!isRawAsset(result)) {
+		throw new Error(`Expected ${itemPath} to be an asset.`);
+	}
+
+	return result;
+}

package/src/dto/entry/beaconReplacer/lib/process.ts

@@ -0,0 +1,10 @@
+import type { Entry } from '#cli/cs/entries/Types.js';
+import type BeaconReplacer from '../../BeaconReplacer.js';
+
+export default function process(this: BeaconReplacer, entry: Entry): Entry {
+	this.refPath = `${this.contentType.uid}/${entry.title}`;
+	const phase1 = this.stripTaxonomies(entry);
+	const phase2 = this.processObject(phase1);
+	this.refPath = undefined;
+	return phase2 as unknown as Entry;
+}

package/src/dto/entry/beaconReplacer/lib/processAsset.ts

@@ -0,0 +1,9 @@
+import type BeaconReplacer from '../../BeaconReplacer.js';
+
+export default function processAsset(
+	this: BeaconReplacer,
+	assetItemPath: string,
+) {
+	const asset = this.mapItemPathToAsset(assetItemPath);
+	return { ...asset, ACL: [] };
+}

package/src/dto/entry/beaconReplacer/lib/processJsonRteAsset.ts

@@ -0,0 +1,17 @@
+import type BeaconReplacer from '../../BeaconReplacer.js';
+
+export default function processJsonRteAsset(
+	this: BeaconReplacer,
+	value: Record<string, unknown>,
+	jsonRteItemPath: string,
+) {
+	const asset = this.mapItemPathToAsset(jsonRteItemPath);
+
+	const { $beacon: _, ...rest } = value;
+
+	return this.processObject({
+		...rest,
+		'asset-uid': asset.uid,
+		'content-type-uid': 'sys_assets',
+	});
+}

package/src/dto/entry/beaconReplacer/lib/processObject.ts

@@ -0,0 +1,10 @@
+import type BeaconReplacer from '../../BeaconReplacer.js';
+
+export default function processObject(
+	this: BeaconReplacer,
+	o: Record<string, unknown>,
+): Record<string, unknown> {
+	return Object.fromEntries(
+		Object.entries(o).map(([key, value]) => [key, this.processValue(value)]),
+	);
+}

package/src/dto/entry/beaconReplacer/lib/processReference.ts

@@ -0,0 +1,19 @@
+import parseReferencePath from '#cli/cs/entries/parseReferencePath.js';
+import type { ReferencePath } from '#cli/cs/entries/Types.js';
+import type BeaconReplacer from '../../BeaconReplacer.js';
+
+export default function processReference(
+	this: BeaconReplacer,
+	targetPath: ReferencePath,
+) {
+	const { refPath } = this;
+
+	if (!refPath) {
+		throw new Error('No reference path.');
+	}
+
+	return {
+		_content_type_uid: parseReferencePath(targetPath).contentTypeUid,
+		uid: this.ctx.references.findReferencedUid(refPath, targetPath),
+	};
+}

package/src/dto/entry/beaconReplacer/lib/processValue.ts

@@ -0,0 +1,41 @@
+import { isReferencePath } from '#cli/cs/entries/Types.js';
+import isRecord from '#cli/util/isRecord.js';
+import type BeaconReplacer from '../../BeaconReplacer.js';
+
+export default function processValue(
+	this: BeaconReplacer,
+	value: unknown,
+): unknown {
+	if (Array.isArray(value)) {
+		return value.map((v) => this.processValue(v));
+	}
+
+	if (!isRecord(value)) {
+		return value;
+	}
+
+	const { $beacon } = value;
+	if (!isRecord($beacon)) {
+		return this.processObject(value);
+	}
+
+	const {
+		asset: assetItemPath,
+		jsonRteAsset: jsonRteItemPath,
+		reference: targetPath,
+	} = $beacon;
+
+	if (typeof assetItemPath === 'string') {
+		return this.processAsset(assetItemPath);
+	}
+
+	if (typeof jsonRteItemPath === 'string') {
+		return this.processJsonRteAsset(value, jsonRteItemPath);
+	}
+
+	if (isReferencePath(targetPath)) {
+		return this.processReference(targetPath);
+	}
+
+	throw new Error('Invalid $beacon');
+}

package/src/dto/entry/beaconReplacer/lib/stripTaxonomies.ts

@@ -0,0 +1,40 @@
+import type { Entry } from '#cli/cs/entries/Types.js';
+import taxonomyStrategy from '#cli/dto/taxonomy/taxonomyStrategy.js';
+import type BeaconReplacer from '../../BeaconReplacer.js';
+import { isTaxonomyValue } from '../../lib/TaxonomyValue.js';
+
+export default function stripTaxonomies(this: BeaconReplacer, entry: Entry) {
+	const field = this.contentType.schema.find((x) => x.data_type === 'taxonomy');
+	if (!field) {
+		return entry;
+	}
+
+	const value = entry[field.uid];
+	if (!value) {
+		return entry;
+	}
+
+	if (!Array.isArray(value)) {
+		return entry;
+	}
+
+	const updated = (value as unknown[]).filter((x) => {
+		if (!isTaxonomyValue(x)) {
+			return true;
+		}
+
+		const strategy = taxonomyStrategy(x.taxonomy_uid);
+		return strategy === 'taxonomy and terms';
+	});
+
+	if (updated.length) {
+		return { ...entry, [field.uid]: updated };
+	}
+
+	const clone = { ...entry };
+	// Justification: We are removing the field from the entry because it
+	// contains no further taxonomies that we wish to update.
+	// eslint-disable-next-line @typescript-eslint/no-dynamic-delete
+	delete clone[field.uid];
+	return clone;
+}

package/src/dto/entry/fromCs.ts

@@ -0,0 +1,22 @@
+import type { ContentType } from '#cli/cs/content-types/Types.js';
+import type { Entry, ReferencePath } from '#cli/cs/entries/Types.js';
+import EntryWalker from '#cli/cs/entryWalker/EntryWalker.js';
+import type Ctx from '#cli/schema/ctx/Ctx.js';
+import ReplacerPipeline from './lib/ReplacerPipeline.js';
+
+export default function fromCs(
+	ctx: Ctx,
+	contentType: ContentType,
+	entry: Entry,
+) {
+	const refPath: ReferencePath = `${contentType.uid}/${entry.title}`;
+	const pipeline = new ReplacerPipeline(ctx, refPath);
+
+	const walker = new EntryWalker(
+		ctx.cs.globalFields,
+		refPath,
+		pipeline.process.bind(pipeline),
+	);
+
+	return walker.process(contentType.schema, entry);
+}

package/src/dto/entry/lib/AssetReplacer.ts

@@ -0,0 +1,72 @@
+import type { RawAssetItem } from '#cli/cs/assets/Types.js';
+import type { ReferencePath } from '#cli/cs/entries/Types.js';
+import type { SchemaField } from '#cli/cs/Types.js';
+import { isItem } from '#cli/cs/Types.js';
+import resolveItemPath from '#cli/schema/assets/lib/resolveItemPath.js';
+import type Ctx from '#cli/schema/ctx/Ctx.js';
+import getUi from '#cli/schema/lib/SchemaUi.js';
+import createStylus from '#cli/ui/createStylus.js';
+import type Replacer from './Replacer.js';
+
+export default class AssetReplacer implements Replacer {
+	readonly #assetsByUid: ReadonlyMap<string, RawAssetItem>;
+	readonly #refPath: ReferencePath;
+
+	public constructor(ctx: Ctx, refPath: ReferencePath) {
+		this.#assetsByUid = ctx.cs.assets.byUid;
+		this.#refPath = refPath;
+	}
+
+	public process(schema: SchemaField, value: unknown) {
+		if (schema.data_type !== 'file') {
+			return value;
+		}
+
+		return schema.multiple
+			? this.#replaceAssets(value)
+			: this.#replaceAsset(value);
+	}
+
+	#replaceAssets(value: unknown) {
+		if (value === null || value === undefined) {
+			return value;
+		}
+
+		if (!Array.isArray(value)) {
+			const y = createStylus('yellowBright');
+			const msg1 = y`Expected an array of assets in entry ${this.#refPath},`;
+			const msg2 = y`but found [${typeof value}]:`;
+			getUi().warn(msg1, msg2, value);
+			return value;
+		}
+
+		return value.map(this.#replaceAsset.bind(this)).filter(Boolean);
+	}
+
+	#replaceAsset(value: unknown) {
+		if (value === null || value === undefined) {
+			return value;
+		}
+
+		if (!isItem(value)) {
+			const y = createStylus('yellowBright');
+			const msg = y`Entry ${this.#refPath} references an invalid asset:`;
+			getUi().warn(msg, value);
+			return value;
+		}
+
+		const asset = this.#assetsByUid.get(value.uid);
+
+		if (!asset) {
+			const y = createStylus('yellowBright');
+			const msg1 = y`Entry ${this.#refPath} references an unknown asset:`;
+			const msg2 = y`${value.uid}.`;
+			getUi().warn(msg1, msg2);
+			return value;
+		}
+
+		const itemPath = resolveItemPath(this.#assetsByUid, asset);
+
+		return { $beacon: { asset: itemPath } };
+	}
+}

package/src/dto/entry/lib/BooleanDefaults.ts

@@ -0,0 +1,23 @@
+import type { SchemaField } from '#cli/cs/Types.js';
+import type Replacer from './Replacer.js';
+
+// 2024-04-06: Observed that an entry containing a boolean field that appears
+// as `false` in the UI may be exported as either `false` or entirely missing
+// from the JSON.
+//
+// If the field is really set to `false` in the JSON, everything is fine.
+//
+// However, if the field is missing from the JSON, then importing the entry
+// into a different stack will cause the field to be set to `false`, which
+// is good, but then if a second import takes place, the field is detected
+// as being different (`false !== undefined`), so the entry is re-imported.
+//
+// We wish to avoid this re-import behavior. To do so, we detect missing
+// boolean fields and set them to `false` as we read the entry from CS.
+export default class BooleanDefaults implements Replacer {
+	public process(schema: SchemaField, value: unknown) {
+		return schema.data_type === 'boolean' && value === undefined
+			? false
+			: value;
+	}
+}

package/src/dto/entry/lib/JsonRteReplacer.ts

@@ -0,0 +1,87 @@
+import type { RawAssetItem } from '#cli/cs/assets/Types.js';
+import type { ReferencePath } from '#cli/cs/entries/Types.js';
+import type { SchemaField } from '#cli/cs/Types.js';
+import resolveItemPath from '#cli/schema/assets/lib/resolveItemPath.js';
+import type Ctx from '#cli/schema/ctx/Ctx.js';
+import getUi from '#cli/schema/lib/SchemaUi.js';
+import createStylus from '#cli/ui/createStylus.js';
+import isRecord from '#cli/util/isRecord.js';
+import { inspect } from 'node:util';
+import isJsonRteField from './isJsonRteField.js';
+import type Replacer from './Replacer.js';
+
+export default class JsonRteReplacer implements Replacer {
+	readonly #assetsByUid: ReadonlyMap<string, RawAssetItem>;
+	readonly #refPath: ReferencePath;
+
+	public constructor(ctx: Ctx, refPath: ReferencePath) {
+		this.#assetsByUid = ctx.cs.assets.byUid;
+		this.#refPath = refPath;
+	}
+
+	public process(schema: SchemaField, value: unknown) {
+		if (!isJsonRteField(schema) || !isRecord(value)) {
+			return value;
+		}
+
+		const { _version, ...node } = value;
+
+		return this.#processNode(node);
+	}
+
+	#processNode({
+		uid,
+		...node
+	}: Record<string, unknown>): Record<string, unknown> {
+		const { children } = node;
+
+		this.#mutateReferenceNode(node);
+
+		if (Array.isArray(children)) {
+			node.children = children.map((child) =>
+				isRecord(child) ? this.#processNode(child) : (child as unknown),
+			);
+		}
+
+		return node;
+	}
+
+	#mutateReferenceNode(node: Record<string, unknown>) {
+		if (node.type !== 'reference') {
+			return;
+		}
+
+		const { attrs } = node;
+		if (!isRecord(attrs)) {
+			return;
+		}
+
+		const { 'content-type-uid': contentTypeUid, 'asset-uid': assetUid } = attrs;
+		if (contentTypeUid === 'sys_assets' && typeof assetUid === 'string') {
+			this.#mutateAssetNode(attrs, assetUid);
+			return;
+		}
+
+		const y = createStylus('yellowBright');
+		const msg1 = y`Entry ${this.#refPath} has an unhandled reference:`;
+		const msg2 = inspect(attrs, { colors: true });
+		getUi().warn(msg1, msg2);
+	}
+
+	#mutateAssetNode(attrs: Record<string, unknown>, assetUid: string) {
+		const asset = this.#assetsByUid.get(assetUid);
+
+		if (!asset) {
+			const y = createStylus('yellowBright');
+			const msg1 = y`Entry ${this.#refPath} references an unknown asset:`;
+			const msg2 = y`${assetUid}.`;
+			getUi().warn(msg1, msg2);
+			return;
+		}
+
+		const itemPath = resolveItemPath(this.#assetsByUid, asset);
+		delete attrs['content-type-uid'];
+		delete attrs['asset-uid'];
+		attrs.$beacon = { jsonRteAsset: itemPath };
+	}
+}

package/src/dto/entry/lib/MinimalCtx.ts

@@ -0,0 +1,8 @@
+import type Ctx from '#cli/schema/ctx/Ctx.js';
+import type ReadonlyReferenceMap from '#cli/schema/references/ReferenceMap.js';
+
+type MinimalCtx = Pick<Ctx, 'cs'> & {
+	readonly references: ReadonlyReferenceMap;
+};
+
+export default MinimalCtx;

package/src/dto/entry/lib/ReferenceReplacer.ts

@@ -0,0 +1,82 @@
+import type { ContentType } from '#cli/cs/content-types/Types.js';
+import type { Entry, ReferencePath } from '#cli/cs/entries/Types.js';
+import type { SchemaField } from '#cli/cs/Types.js';
+import type Ctx from '#cli/schema/ctx/Ctx.js';
+import type EntryCollection from '#cli/schema/entries/EntryCollection.js';
+import getUi from '#cli/schema/lib/SchemaUi.js';
+import createStylus from '#cli/ui/createStylus.js';
+import isRecord from '#cli/util/isRecord.js';
+import type Replacer from './Replacer.js';
+
+export default class ReferenceReplacer implements Replacer {
+	readonly #refPath: ReferencePath;
+	readonly #entries: EntryCollection;
+
+	public constructor(ctx: Ctx, refPath: ReferencePath) {
+		this.#refPath = refPath;
+		this.#entries = ctx.cs.entries;
+	}
+
+	public process(schema: SchemaField, value: unknown) {
+		return schema.data_type === 'reference'
+			? this.#replaceReferences(value)
+			: value;
+	}
+
+	#replaceReferences(value: unknown) {
+		if (value === null || value === undefined) {
+			return;
+		}
+
+		if (!Array.isArray(value)) {
+			const y = createStylus('yellowBright');
+			const msg1 = y`Expected references in entry ${this.#refPath}`;
+			const msg2 = y`to be an array, but found: ${typeof value}:`;
+			getUi().warn(msg1, msg2, value);
+			return value;
+		}
+
+		return value
+			.map(this.#replaceReference.bind(this))
+			.filter((x) => x !== null);
+	}
+
+	#replaceReference(value: unknown, idx: number) {
+		if (!isReference(value)) {
+			const y = createStylus('yellowBright');
+			const msg1 = y`Entry ${this.#refPath} contains an unexpected reference`;
+			const msg2 = y`data structure at index ${idx.toLocaleString()}:`;
+			getUi().warn(msg1, msg2, value);
+			return value;
+		}
+
+		const referencedPath = `${value._content_type_uid}/${value.uid}` as const;
+		const referencedEntry = this.#entries.byTypedUid.get(referencedPath);
+
+		if (!referencedEntry) {
+			const y = createStylus('yellowBright');
+			const msg1 = y`Entry ${this.#refPath} references ${referencedPath},`;
+			const msg2 = 'which does not exist. The invalid reference will be';
+			const msg3 = 'removed.';
+			getUi().warn(msg1, msg2, msg3);
+			return null;
+		}
+
+		const { title } = referencedEntry;
+		const reference: ReferencePath = `${value._content_type_uid}/${title}`;
+		return { $beacon: { reference } };
+	}
+}
+
+interface Reference {
+	readonly uid: Entry['uid'];
+	readonly _content_type_uid: ContentType['uid'];
+}
+
+function isReference(value: unknown): value is Reference {
+	return (
+		isRecord(value) &&
+		typeof value.uid === 'string' &&
+		typeof value._content_type_uid === 'string'
+	);
+}

package/src/dto/entry/lib/Replacer.ts

@@ -0,0 +1,5 @@
+import type { SchemaField } from '#cli/cs/Types.js';
+
+export default interface Replacer {
+	process(schema: SchemaField, value: unknown): unknown;
+}

package/src/dto/entry/lib/ReplacerPipeline.ts

@@ -0,0 +1,33 @@
+import type { ReferencePath } from '#cli/cs/entries/Types.js';
+import type { SchemaField } from '#cli/cs/Types.js';
+import type Ctx from '#cli/schema/ctx/Ctx.js';
+import AssetReplacer from './AssetReplacer.js';
+import BooleanDefaults from './BooleanDefaults.js';
+import JsonRteReplacer from './JsonRteReplacer.js';
+import ReferenceReplacer from './ReferenceReplacer.js';
+import type Replacer from './Replacer.js';
+import TaxonomyRemover from './TaxonomyRemover.js';
+
+export default class ReplacerPipeline {
+	readonly #replacers: Replacer[];
+
+	public constructor(ctx: Ctx, refPath: ReferencePath) {
+		this.#replacers = [
+			new AssetReplacer(ctx, refPath),
+			new ReferenceReplacer(ctx, refPath),
+			new JsonRteReplacer(ctx, refPath),
+			new TaxonomyRemover(refPath),
+			new BooleanDefaults(),
+		];
+	}
+
+	public process(field: SchemaField, value: unknown) {
+		let result = value;
+
+		for (const replacer of this.#replacers) {
+			result = replacer.process(field, result);
+		}
+
+		return result;
+	}
+}

package/src/dto/entry/lib/TaxonomyRemover.ts

@@ -0,0 +1,58 @@
+import type { ReferencePath } from '#cli/cs/entries/Types.js';
+import type { SchemaField } from '#cli/cs/Types.js';
+import getUi from '#cli/schema/lib/SchemaUi.js';
+import createStylus from '#cli/ui/createStylus.js';
+import taxonomyStrategy from '../../taxonomy/taxonomyStrategy.js';
+import type Replacer from './Replacer.js';
+import { isTaxonomyValue } from './TaxonomyValue.js';
+
+export default class TaxonomyRemover implements Replacer {
+	readonly #refPath: ReferencePath;
+
+	public constructor(refPath: ReferencePath) {
+		this.#refPath = refPath;
+	}
+
+	public process(schema: SchemaField, value: unknown) {
+		return schema.data_type === 'taxonomy'
+			? this.#removeTaxonomies(value)
+			: value;
+	}
+
+	#removeTaxonomies(value: unknown) {
+		if (value === null || value === undefined) {
+			return;
+		}
+
+		if (!Array.isArray(value)) {
+			const y = createStylus('yellowBright');
+			const msg1 = y`Expected taxonomies in entry ${this.#refPath}`;
+			const msg2 = y`to be an array, but found: ${typeof value}:`;
+			getUi().warn(msg1, msg2, value);
+			return value;
+		}
+
+		const result = (value as unknown[]).filter((x, idx) => {
+			if (!isTaxonomyValue(x)) {
+				const y = createStylus('yellowBright');
+				const msg1 = y`Entry ${this.#refPath} contains an unexpected taxonomy`;
+				const msg2 = y`data structure at index ${idx.toLocaleString()}:`;
+				getUi().warn(msg1, msg2, value);
+				return true;
+			}
+
+			const strategy = taxonomyStrategy(x.taxonomy_uid);
+			return strategy === 'taxonomy and terms';
+		});
+
+		// 2025-04-06: Observed an otherwise identical entry in two different stacks
+		// with no taxonomies, in which one stack returned `taxonomies: []` and the
+		// other stack returned no `taxonomies` field at all.
+		//
+		// We need to consider these two entries to be equal. I am solving for this
+		// by stripping away any empty taxonomy arrays while reading from CS.
+		if (result.length) {
+			return result;
+		}
+	}
+}

package/src/dto/entry/lib/TaxonomyValue.ts

@@ -0,0 +1,14 @@
+import isRecord from '#cli/util/isRecord.js';
+
+export default interface TaxonomyValue {
+	readonly taxonomy_uid: string;
+	readonly term_uid: string;
+}
+
+export function isTaxonomyValue(value: unknown): value is TaxonomyValue {
+	return (
+		isRecord(value) &&
+		typeof value.taxonomy_uid === 'string' &&
+		typeof value.term_uid === 'string'
+	);
+}

package/src/dto/entry/lib/isJsonRteField.ts

@@ -0,0 +1,30 @@
+import type { SchemaField } from '#cli/cs/Types.js';
+import isRecord from '#cli/util/isRecord.js';
+
+export default function isJsonRteField(
+	schema: SchemaField | undefined,
+): schema is SchemaField & {
+	readonly data_type: 'json';
+	readonly field_metadata: Record<string, unknown> & {
+		readonly allow_json_rte: true;
+	};
+} {
+	if (!schema) {
+		return false;
+	}
+
+	if (schema.data_type !== 'json') {
+		return false;
+	}
+
+	if ('extension_uid' in schema) {
+		return false;
+	}
+
+	const metadata = schema.field_metadata;
+	if (!isRecord(metadata)) {
+		return false;
+	}
+
+	return Boolean(metadata.allow_json_rte);
+}

package/src/dto/entry/toCs.ts

@@ -0,0 +1,13 @@
+import type { ContentType } from '../../cs/content-types/Types.js';
+import type { Entry } from '../../cs/entries/Types.js';
+import BeaconReplacer from './BeaconReplacer.js';
+import type MinimalCtx from './lib/MinimalCtx.js';
+
+export default function toCs(
+	ctx: MinimalCtx,
+	contentType: ContentType,
+	entry: Entry,
+) {
+	const replacer = new BeaconReplacer(ctx, contentType);
+	return replacer.process(entry);
+}