@sarimarcus/content-sites-core 0.22.1 → 0.22.2

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 All packages in the platform release in lockstep; entries are per release version.
 
+## 0.22.2 (2026-10-04)
+
+- `./schema`: `offer`, `placeNode`, `siteOrganizationNode`, `siteWebsiteNode`, `isFreeEntry` and `renderSchemaPolicy` (with the `SchemaPolicy` type) replace node skeletons repeated across builders and site adapters (SLA-2918).
+- `./schema`: an event offer's `validFrom` is now three months before the start in UTC, clamped to the target month's last day. It used to follow the build machine's timezone (a Paris build emitted `…T23:00Z`/`…T01:00Z`, a UTC build `…T00:00Z`) and overflowed short months (31 May → early March). Event pages and event lists change only in this field (SLA-2918).
+- `./url`: `outboundClassifier` and `outboundHostKey`, the one Rule 38 host lookup; `./config` `outboundLinkRel` uses it (SLA-2918).
+
+### Deprecated
+
+- `./schema` `touristTripBuilder` and `TouristTripOptions`: tourism-only; import them from `@sarimarcus/content-sites-tourism/schema`. Removed in the next minor (SLA-2918).
+
 ## 0.22.1 (2026-10-04)
 
 - No changes; lockstep release with ui (SLA-2920).

package/dist/config/outboundLinkRel.js

@@ -1,6 +1,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
+import { outboundClassifier } from "../url/outbound.js";
 function walk(dir, out = []) {
     let entries;
     try {
@@ -38,8 +39,7 @@ export function outboundLinkRel({ root }) {
         name: 'outbound-link-rel',
         hooks: {
             'astro:build:done': async ({ dir, logger }) => {
-                const store = JSON.parse(fs.readFileSync(path.join(siteRoot, 'src/data/outbound-domains.json'), 'utf-8'));
-                const classes = new Map(Object.entries(store.domains).map(([d, e]) => [d.replace(/^www\./, '').toLowerCase(), e.class]));
+                const classify = outboundClassifier(JSON.parse(fs.readFileSync(path.join(siteRoot, 'src/data/outbound-domains.json'), 'utf-8')));
                 const outDir = fileURLToPath(dir);
                 let files = 0;
                 let anchors = 0;
@@ -50,14 +50,7 @@ export function outboundLinkRel({ root }) {
                         const href = attrs.match(/href\s*=\s*"([^"]*)"/i)?.[1] ?? attrs.match(/href\s*=\s*'([^']*)'/i)?.[1];
                         if (!href || !/^https?:\/\//i.test(href))
                             return tag;
-                        let host;
-                        try {
-                            host = new URL(href).hostname.toLowerCase().replace(/^www\./, '');
-                        }
-                        catch {
-                            return tag;
-                        }
-                        const cls = classes.get(host) ?? 'other';
+                        const cls = classify(href);
                         if (cls !== 'competitor' && cls !== 'affiliate')
                             return tag;
                         anchors++;

package/dist/schema/events.js

@@ -1,17 +1,19 @@
 import { createPersonSchema } from "./context.js";
-import { geoCoordinates, postalAddress } from "./values.js";
+import { offer } from "./nodes.js";
+import { geoCoordinates, isFreeEntry, parsePriceFromString, postalAddress } from "./values.js";
 function eventPrice(data) {
-    const isFree = data.tags?.includes('free') || data.price?.toLowerCase().includes('free');
-    const priceMatch = data.price?.match(/(\d+)/);
-    return { isFree, price: isFree ? 0 : (priceMatch ? parseFloat(priceMatch[1]) : null) };
+    const isFree = isFreeEntry(data);
+    return { isFree, price: isFree ? 0 : parsePriceFromString(data.price) };
 }
-// Offers open three months before the start date.
-function validFrom(startDate) {
+/** Offers open three months before the start date, in UTC; a day the target month lacks clamps to its last day. */
+function offerValidFrom(startDate) {
     if (!startDate)
         return null;
-    const from = new Date(new Date(startDate));
-    from.setMonth(from.getMonth() - 3);
-    return from.toISOString();
+    const start = new Date(startDate);
+    const year = start.getUTCFullYear();
+    const month = start.getUTCMonth() - 3;
+    const lastDay = new Date(Date.UTC(year, month + 1, 0)).getUTCDate();
+    return new Date(Date.UTC(year, month, Math.min(start.getUTCDate(), lastDay), start.getUTCHours(), start.getUTCMinutes(), start.getUTCSeconds(), start.getUTCMilliseconds())).toISOString();
 }
 function eventLocation(policy, data) {
     const name = data.location || policy.defaultLocationName;
@@ -27,48 +29,43 @@ function eventLocation(policy, data) {
 }
 const EVENT_STATUS = (rescheduled) => (rescheduled ? 'https://schema.org/EventRescheduled' : 'https://schema.org/EventScheduled');
 const OFFLINE = 'https://schema.org/OfflineEventAttendanceMode';
+/** An Event node: its dates, status, attendance mode, free entry, location, organizer, performer and offers. */
+function eventNode(ctx, policy, data, parts) {
+    return {
+        '@type': 'Event',
+        name: data.name,
+        description: data.description,
+        image: ctx.resolveImageUrl(data.image, data.slug),
+        ...parts.head,
+        startDate: data.startDate || undefined,
+        endDate: data.endDate || undefined,
+        previousStartDate: data.previousStartDate || undefined,
+        eventStatus: EVENT_STATUS(data.previousStartDate),
+        eventAttendanceMode: OFFLINE,
+        isAccessibleForFree: parts.isFree,
+        location: eventLocation(policy, data),
+        organizer: parts.organizer,
+        performer: policy.performer(data),
+        offers: parts.offers,
+        ...parts.tail,
+    };
+}
 /** Event at route `event`, its author's Person first, and a companion Article (SLA-357). */
 export function eventBuilder(options) {
     const { offersArray = false, emitEvent = () => true, articleSection = 'Events', inLanguage = 'en', currency = 'EUR' } = options;
     return (data, ctx) => {
         const { isFree, price } = eventPrice(data);
-        const from = validFrom(data.startDate);
+        const validFrom = offerValidFrom(data.startDate);
         const pageRoute = ctx.route('event', data.slug);
-        const singleOffer = price !== null ? {
-            '@type': 'Offer',
-            price,
-            priceCurrency: currency,
-            availability: 'https://schema.org/InStock',
-            url: data.officialWebsite || pageRoute,
-            validFrom: from,
-        } : undefined;
-        const event = {
-            '@type': 'Event',
-            name: data.name,
-            description: data.description,
-            image: ctx.resolveImageUrl(data.image, data.slug),
-            startDate: data.startDate || undefined,
-            endDate: data.endDate || undefined,
-            previousStartDate: data.previousStartDate || undefined,
-            eventStatus: EVENT_STATUS(data.previousStartDate),
-            eventAttendanceMode: OFFLINE,
-            isAccessibleForFree: isFree,
-            location: eventLocation(options, data),
+        const offers = offersArray && (data.offers?.length ?? 0) > 0
+            ? data.offers.map((o) => offer(o.price, o.priceCurrency || currency, { availability: o.availability || undefined, url: o.url || data.officialWebsite || pageRoute, validFrom }))
+            : price !== null ? offer(price, currency, { url: data.officialWebsite || pageRoute, validFrom }) : undefined;
+        const event = eventNode(ctx, options, data, {
+            isFree,
             organizer: options.organizer(data),
-            performer: options.performer(data),
-            offers: offersArray && (data.offers?.length ?? 0) > 0
-                ? data.offers.map((o) => ({
-                    '@type': 'Offer',
-                    price: o.price,
-                    priceCurrency: o.priceCurrency || currency,
-                    availability: `https://schema.org/${o.availability || 'InStock'}`,
-                    url: o.url || data.officialWebsite || pageRoute,
-                    validFrom: from,
-                }))
-                : singleOffer,
-            mainEntityOfPage: { '@id': ctx.pageUrl },
-            url: pageRoute,
-        };
+            offers,
+            tail: { mainEntityOfPage: { '@id': ctx.pageUrl }, url: pageRoute },
+        });
         const author = ctx.resolveAuthor(data.author);
         const article = {
             '@type': 'Article',
@@ -96,9 +93,6 @@ export function eventItemListBuilder(options) {
         name: data.name,
         numberOfItems: data.items?.length || 0,
         itemListElement: data.items?.map((item) => {
-            const { isFree, price } = eventPrice(item);
-            const from = validFrom(item.startDate);
-            const performer = options.performer(item);
             if (!isEvent(item)) {
                 return {
                     '@type': 'ListItem',
@@ -106,33 +100,18 @@ export function eventItemListBuilder(options) {
                     item: { '@type': 'WebPage', name: item.name, description: item.description, url: ctx.abs(item.url) },
                 };
             }
+            const { isFree, price } = eventPrice(item);
             return {
                 '@type': 'ListItem',
                 position: item.position,
-                item: {
-                    '@type': 'Event',
-                    name: item.name,
-                    description: item.description,
-                    image: ctx.resolveImageUrl(item.image, item.slug),
-                    url: ctx.abs(item.url),
-                    startDate: item.startDate,
-                    endDate: item.endDate,
-                    previousStartDate: item.previousStartDate || undefined,
-                    eventStatus: EVENT_STATUS(item.previousStartDate),
-                    eventAttendanceMode: OFFLINE,
-                    isAccessibleForFree: isFree,
-                    location: eventLocation(options, item),
+                item: eventNode(ctx, options, item, {
+                    head: { url: ctx.abs(item.url) },
+                    isFree,
                     organizer: options.itemOrganizer(item),
-                    performer,
-                    offers: price !== null ? {
-                        '@type': 'Offer',
-                        price,
-                        priceCurrency: currency,
-                        availability: 'https://schema.org/InStock',
-                        url: item.officialWebsite || ctx.route('event', item.slug),
-                        validFrom: from,
-                    } : undefined,
-                },
+                    offers: price !== null ? offer(price, currency, {
+                        url: item.officialWebsite || ctx.route('event', item.slug), validFrom: offerValidFrom(item.startDate),
+                    }) : undefined,
+                }),
             };
         }),
     });

package/dist/schema/index.d.ts

@@ -1,9 +1,13 @@
 export type { JsonLdNode, SchemaEntry, OpeningHoursSpecification, IdRef, SchemaAuthorProfile, ResolvedAuthor, RouteMap, SchemaContextInput, SchemaContext, SchemaBuilder, SchemaBuilders, } from './types.ts';
 export { createSchemaContext, normalizeHomepageUrl, normalizeStructuredDataUrls, formatSchemaDate, createPersonSchema, withAuthorPersonSchema, } from './context.ts';
-export { parsePriceFromString, cleanStreetAddress, normalizePriceRange, normalizeHotelPriceRange, postalCodeOf, dataAddressPolicy, postalAddress, geoCoordinates, aggregateRating, } from './values.ts';
+export { parsePriceFromString, isFreeEntry, cleanStreetAddress, normalizePriceRange, normalizeHotelPriceRange, postalCodeOf, dataAddressPolicy, postalAddress, geoCoordinates, aggregateRating, } from './values.ts';
 export type { AddressPolicy, PostalAddressParts } from './values.ts';
 export { DAY_KEYS, HOURS_ALWAYS_OPEN, parseHoursShifts, closedFieldDays, resolveOpeningHours, assertedOpenDays, generateOpeningHours, parseHoursString, hoursStringOpenDays, } from './hours.ts';
 export type { DayKey, OpeningHoursInput, OpeningHoursBucket } from './hours.ts';
+export { renderSchemaPolicy } from './policy.ts';
+export type { SchemaPolicy } from './policy.ts';
+export { offer, placeNode, siteOrganizationNode, siteWebsiteNode } from './nodes.ts';
+export type { OfferFields, SiteNodeFields, OrganizationLogo } from './nodes.ts';
 export { buildBreadcrumbList, buildWebPageNode, assembleGraph, finalizeGraph } from './graph.ts';
 export type { BreadcrumbInput, PageInput, AssembleOptions } from './graph.ts';
 export { faqPageBuilder, articleBuilder, collectionPageBuilder, itemListBuilder, howToBuilder, aboutPageBuilder, contactPageBuilder, personBuilder, aggregateOfferBuilder, touristDestinationBuilder, organizationBuilder, } from './pages.ts';

package/dist/schema/index.js

@@ -1,6 +1,8 @@
 export { createSchemaContext, normalizeHomepageUrl, normalizeStructuredDataUrls, formatSchemaDate, createPersonSchema, withAuthorPersonSchema, } from "./context.js";
-export { parsePriceFromString, cleanStreetAddress, normalizePriceRange, normalizeHotelPriceRange, postalCodeOf, dataAddressPolicy, postalAddress, geoCoordinates, aggregateRating, } from "./values.js";
+export { parsePriceFromString, isFreeEntry, cleanStreetAddress, normalizePriceRange, normalizeHotelPriceRange, postalCodeOf, dataAddressPolicy, postalAddress, geoCoordinates, aggregateRating, } from "./values.js";
 export { DAY_KEYS, HOURS_ALWAYS_OPEN, parseHoursShifts, closedFieldDays, resolveOpeningHours, assertedOpenDays, generateOpeningHours, parseHoursString, hoursStringOpenDays, } from "./hours.js";
+export { renderSchemaPolicy } from "./policy.js";
+export { offer, placeNode, siteOrganizationNode, siteWebsiteNode } from "./nodes.js";
 export { buildBreadcrumbList, buildWebPageNode, assembleGraph, finalizeGraph } from "./graph.js";
 export { faqPageBuilder, articleBuilder, collectionPageBuilder, itemListBuilder, howToBuilder, aboutPageBuilder, contactPageBuilder, personBuilder, aggregateOfferBuilder, touristDestinationBuilder, organizationBuilder, } from "./pages.js";
 export { hotelBuilder, activityBuilder, touristTripBuilder } from "./places.js";

package/dist/schema/nodes.d.ts

@@ -0,0 +1,28 @@
+import type { JsonLdNode, SchemaContext } from './types.ts';
+export interface OfferFields {
+    /** schema.org ItemAvailability name. */
+    availability?: string;
+    url?: string;
+    validFrom?: string | null;
+    description?: string;
+}
+/** An Offer; `url`, `validFrom` and `description` follow in the order given. */
+export declare function offer(price: number | null, currency: string, { availability, ...rest }?: OfferFields): JsonLdNode;
+/**
+ * An entity page's node, preceded by its author's Person: type, name, description and image, then `fields` in their
+ * order, then `mainEntityOfPage` and the `route` URL. A field named `image` replaces the resolved image in place.
+ */
+export declare function placeNode(ctx: SchemaContext, data: Record<string, any>, type: string | string[], route: string, fields: JsonLdNode): JsonLdNode | JsonLdNode[];
+export interface SiteNodeFields {
+    name: string;
+    description: string;
+}
+export interface OrganizationLogo {
+    path: string;
+    width?: number;
+    height?: number;
+}
+/** The base graph's Organization; `extra` (sameAs, knowsAbout, …) follows the description. */
+export declare function siteOrganizationNode(ctx: SchemaContext, { name, description }: SiteNodeFields, logo?: OrganizationLogo, extra?: JsonLdNode): JsonLdNode;
+/** The base graph's WebSite, published by the Organization; `extra` (a SearchAction, …) follows. */
+export declare function siteWebsiteNode(ctx: SchemaContext, { name, description }: SiteNodeFields, extra?: JsonLdNode): JsonLdNode;

package/dist/schema/nodes.js

@@ -0,0 +1,49 @@
+import { withAuthorPersonSchema } from "./context.js";
+/** An Offer; `url`, `validFrom` and `description` follow in the order given. */
+export function offer(price, currency, { availability = 'InStock', ...rest } = {}) {
+    return { '@type': 'Offer', price, priceCurrency: currency, availability: `https://schema.org/${availability}`, ...rest };
+}
+/**
+ * An entity page's node, preceded by its author's Person: type, name, description and image, then `fields` in their
+ * order, then `mainEntityOfPage` and the `route` URL. A field named `image` replaces the resolved image in place.
+ */
+export function placeNode(ctx, data, type, route, fields) {
+    return withAuthorPersonSchema(ctx, {
+        '@type': type,
+        name: data.name,
+        description: data.description,
+        image: ctx.resolveImageUrl(data.image, data.slug),
+        ...fields,
+        mainEntityOfPage: { '@id': ctx.pageUrl },
+        url: ctx.route(route, data.slug),
+    }, data.author);
+}
+/** The base graph's Organization; `extra` (sameAs, knowsAbout, …) follows the description. */
+export function siteOrganizationNode(ctx, { name, description }, logo = { path: '/favicon.svg' }, extra = {}) {
+    const logoUrl = ctx.abs(logo.path);
+    return {
+        '@type': 'Organization',
+        '@id': ctx.orgId,
+        name,
+        url: ctx.siteBaseUrl,
+        logo: {
+            '@type': 'ImageObject', url: logoUrl, contentUrl: logoUrl,
+            ...(logo.width && { width: logo.width }), ...(logo.height && { height: logo.height }),
+        },
+        description,
+        ...extra,
+    };
+}
+/** The base graph's WebSite, published by the Organization; `extra` (a SearchAction, …) follows. */
+export function siteWebsiteNode(ctx, { name, description }, extra = {}) {
+    return {
+        '@type': 'WebSite',
+        '@id': ctx.websiteId,
+        name,
+        description,
+        url: ctx.siteBaseUrl,
+        inLanguage: 'en',
+        publisher: { '@id': ctx.orgId },
+        ...extra,
+    };
+}

package/dist/schema/places.d.ts

@@ -23,5 +23,8 @@ export interface TouristTripOptions {
     offerDescription?: string;
     currency?: string;
 }
-/** A free self-guided TouristTrip at route `walk`, its stops as the itinerary. */
+/**
+ * A free self-guided TouristTrip at route `walk`, its stops as the itinerary.
+ * @deprecated Tourism-only: import `touristTripBuilder` from `@sarimarcus/content-sites-tourism/schema` (SLA-2918).
+ */
 export declare function touristTripBuilder(options?: TouristTripOptions): SchemaBuilder;

package/dist/schema/places.js

@@ -1,15 +1,12 @@
-import { withAuthorPersonSchema } from "./context.js";
 import { generateOpeningHours } from "./hours.js";
+import { offer, placeNode } from "./nodes.js";
 import { aggregateRating, geoCoordinates, normalizeHotelPriceRange, parsePriceFromString, postalAddress, postalCodeOf, } from "./values.js";
 /** Hotel at route `hotel`; no `openingHours` means open around the clock. */
 export function hotelBuilder(options) {
     const { address, defaultCheckinTime = '14:00', defaultCheckoutTime = '12:00' } = options;
     return (data, ctx) => {
         const imageUrl = ctx.resolveImageUrl(data.image, data.slug);
-        return withAuthorPersonSchema(ctx, {
-            '@type': 'Hotel',
-            name: data.name,
-            description: data.description,
+        return placeNode(ctx, data, 'Hotel', 'hotel', {
             image: imageUrl ? { '@type': 'ImageObject', url: imageUrl } : undefined,
             address: postalAddress(address, data, { street: data.address, postalCode: postalCodeOf(data) }),
             geo: geoCoordinates(data.coordinates),
@@ -26,19 +23,13 @@ export function hotelBuilder(options) {
             checkoutTime: data.checkoutTime || defaultCheckoutTime,
             openingHoursSpecification: generateOpeningHours(data.openingHours || { alwaysOpen: true }),
             sameAs: data.website ? [data.website] : undefined,
-            mainEntityOfPage: { '@id': ctx.pageUrl },
-            url: ctx.route('hotel', data.slug),
-        }, data.author);
+        });
     };
 }
 /** TouristAttraction at route `activity`; the street falls back to `meetingPoint`. */
 export function activityBuilder(options) {
     const { address, touristType = 'Cultural', defaultLanguages, offers = false, currency = 'EUR' } = options;
-    return (data, ctx) => withAuthorPersonSchema(ctx, {
-        '@type': 'TouristAttraction',
-        name: data.name,
-        description: data.description,
-        image: ctx.resolveImageUrl(data.image, data.slug),
+    return (data, ctx) => placeNode(ctx, data, 'TouristAttraction', 'activity', {
         address: postalAddress(address, data, { street: data.address || data.meetingPoint, postalCode: postalCodeOf(data) }),
         geo: geoCoordinates(data.coordinates),
         touristType,
@@ -47,32 +38,18 @@ export function activityBuilder(options) {
         availableLanguage: data.languages || defaultLanguages,
         telephone: data.phone,
         aggregateRating: aggregateRating(data),
-        offers: offers && data.priceFrom !== undefined ? {
-            '@type': 'Offer',
-            price: data.priceFrom,
-            priceCurrency: currency,
-            availability: 'https://schema.org/InStock',
-        } : undefined,
-        mainEntityOfPage: { '@id': ctx.pageUrl },
-        url: ctx.route('activity', data.slug),
-    }, data.author);
+        offers: offers && data.priceFrom !== undefined ? offer(data.priceFrom, currency) : undefined,
+    });
 }
-/** A free self-guided TouristTrip at route `walk`, its stops as the itinerary. */
+/**
+ * A free self-guided TouristTrip at route `walk`, its stops as the itinerary.
+ * @deprecated Tourism-only: import `touristTripBuilder` from `@sarimarcus/content-sites-tourism/schema` (SLA-2918).
+ */
 export function touristTripBuilder(options = {}) {
     const { touristType = 'Cultural', offerDescription = 'Self-guided walking tour — free', currency = 'EUR' } = options;
-    return (data, ctx) => withAuthorPersonSchema(ctx, {
-        '@type': 'TouristTrip',
-        name: data.name,
-        description: data.description,
-        image: ctx.resolveImageUrl(data.image, data.slug),
+    return (data, ctx) => placeNode(ctx, data, 'TouristTrip', 'walk', {
         touristType: data.theme || touristType,
-        offers: {
-            '@type': 'Offer',
-            price: 0,
-            priceCurrency: currency,
-            availability: 'https://schema.org/InStock',
-            description: offerDescription,
-        },
+        offers: offer(0, currency, { description: offerDescription }),
         itinerary: {
             '@type': 'ItemList',
             numberOfItems: data.stops?.length || 0,
@@ -88,7 +65,5 @@ export function touristTripBuilder(options = {}) {
                 },
             })),
         },
-        mainEntityOfPage: { '@id': ctx.pageUrl },
-        url: ctx.route('walk', data.slug),
-    }, data.author);
+    });
 }

package/dist/schema/policy.d.ts

@@ -0,0 +1,17 @@
+import { type AssembleOptions, type PageInput } from './graph.ts';
+import type { JsonLdNode, SchemaBuilders, SchemaContext, SchemaContextInput, SchemaEntry } from './types.ts';
+/** A site's JSON-LD policy: its context options, base nodes, builders and graph hooks. */
+export interface SchemaPolicy {
+    context?: Partial<SchemaContextInput>;
+    nodes(ctx: SchemaContext): {
+        organization: JsonLdNode;
+        website: JsonLdNode;
+    };
+    builders: SchemaBuilders;
+    hooks?(ctx: SchemaContext, entries: SchemaEntry[]): Pick<AssembleOptions, 'beforeEntries' | 'afterEntries'>;
+}
+/**
+ * One page's finalised JSON-LD under a site policy: context, base nodes, entries, hooks. The site adapter and the
+ * factory schema goldens both render through this, so the goldens test the wiring that ships.
+ */
+export declare function renderSchemaPolicy(input: SchemaContextInput, policy: SchemaPolicy, page: PageInput): JsonLdNode;

package/dist/schema/policy.js

@@ -0,0 +1,15 @@
+import { createSchemaContext } from "./context.js";
+import { assembleGraph, finalizeGraph } from "./graph.js";
+/**
+ * One page's finalised JSON-LD under a site policy: context, base nodes, entries, hooks. The site adapter and the
+ * factory schema goldens both render through this, so the goldens test the wiring that ships.
+ */
+export function renderSchemaPolicy(input, policy, page) {
+    const ctx = createSchemaContext({ ...input, ...policy.context });
+    return finalizeGraph(ctx, assembleGraph(ctx, {
+        ...policy.nodes(ctx),
+        builders: policy.builders,
+        ...page,
+        ...policy.hooks?.(ctx, page.entries),
+    }));
+}

package/dist/schema/values.d.ts

@@ -1,6 +1,11 @@
 import type { JsonLdNode } from './types.ts';
 /** First integer in a price string; any "free" reads as 0; null when there is no number. */
 export declare function parsePriceFromString(priceStr: string | undefined): number | null;
+/**
+ * Free entry: a `free` tag, or "free" in the price text (`price` for events, `fees` for places). `undefined` when
+ * neither is present, so the key drops out of the JSON-LD.
+ */
+export declare function isFreeEntry(data: Record<string, any>, field?: 'price' | 'fees'): boolean | undefined;
 /** Street and number only: drops postal code, city and country, and a second part that is a district or postcode. */
 export declare function cleanStreetAddress(fullAddress: string | undefined): string;
 /** A €-symbol range (`€`…`€€€€`) from a price string, inferred from `priceFrom` when given. */

package/dist/schema/values.js

@@ -7,6 +7,13 @@ export function parsePriceFromString(priceStr) {
     const match = priceStr.match(/(\d+)/);
     return match ? parseFloat(match[1]) : null;
 }
+/**
+ * Free entry: a `free` tag, or "free" in the price text (`price` for events, `fees` for places). `undefined` when
+ * neither is present, so the key drops out of the JSON-LD.
+ */
+export function isFreeEntry(data, field = 'price') {
+    return data.tags?.includes('free') || data[field]?.toLowerCase().includes('free');
+}
 /** Street and number only: drops postal code, city and country, and a second part that is a district or postcode. */
 export function cleanStreetAddress(fullAddress) {
     if (!fullAddress)

package/dist/url/index.d.ts

@@ -5,3 +5,5 @@ export { buildImageMap, keyBySlug } from './imageMap.ts';
 export { articleFeedItem } from './feed.ts';
 export type { FeedArticle, FeedItem } from './feed.ts';
 export { pageTypeOf } from './pageType.ts';
+export { outboundClassifier, outboundHostKey } from './outbound.ts';
+export type { OutboundDomainStore } from './outbound.ts';

package/dist/url/index.js

@@ -5,3 +5,4 @@ export { normalizeHref, extractProseHrefs, dedupRelated } from "./relatedDedup.j
 export { buildImageMap, keyBySlug } from "./imageMap.js";
 export { articleFeedItem } from "./feed.js";
 export { pageTypeOf } from "./pageType.js";
+export { outboundClassifier, outboundHostKey } from "./outbound.js";

package/dist/url/outbound.d.ts

@@ -0,0 +1,13 @@
+/** The outbound-domains store as synced into each site (`src/data/outbound-domains.json`). */
+export interface OutboundDomainStore {
+    domains: Record<string, {
+        class: string;
+    }>;
+}
+/** Host key of the store: lowercase, without `www.`. */
+export declare function outboundHostKey(host: string): string;
+/**
+ * URL → its Rule 38 class (`competitor`, `affiliate`, `official`, …) from the store, or a plain host → class map;
+ * `other` for an unlisted host or a URL that does not parse. Lookup only: each consumer decides what a class renders.
+ */
+export declare function outboundClassifier(store: OutboundDomainStore | Record<string, string>): (url: string) => string;

package/dist/url/outbound.js

@@ -0,0 +1,22 @@
+/** Host key of the store: lowercase, without `www.`. */
+export function outboundHostKey(host) {
+    return host.toLowerCase().replace(/^www\./, '');
+}
+/**
+ * URL → its Rule 38 class (`competitor`, `affiliate`, `official`, …) from the store, or a plain host → class map;
+ * `other` for an unlisted host or a URL that does not parse. Lookup only: each consumer decides what a class renders.
+ */
+export function outboundClassifier(store) {
+    const entries = 'domains' in store && typeof store.domains === 'object'
+        ? Object.entries(store.domains).map(([d, e]) => [d, e.class])
+        : Object.entries(store);
+    const classes = new Map(entries.map(([d, c]) => [outboundHostKey(d), c]));
+    return (url) => {
+        try {
+            return classes.get(outboundHostKey(new URL(url).hostname)) ?? 'other';
+        }
+        catch {
+            return 'other';
+        }
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sarimarcus/content-sites-core",
-  "version": "0.22.1",
+  "version": "0.22.2",
   "description": "Non-visual utilities, Astro config builders and SEO schema assembly shared by the content sites.",
   "type": "module",
   "license": "MIT",

package/src/config/outboundLinkRel.ts

@@ -2,6 +2,7 @@ import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import type { AstroIntegration } from 'astro';
+import { outboundClassifier, type OutboundDomainStore } from '../url/outbound.ts';
 
 export interface OutboundLinkRelOptions {
   /** Site root; the classification store is read from `src/data/outbound-domains.json` under it. */
@@ -44,10 +45,9 @@ export function outboundLinkRel({ root }: OutboundLinkRelOptions): AstroIntegrat
     name: 'outbound-link-rel',
     hooks: {
       'astro:build:done': async ({ dir, logger }) => {
-        const store = JSON.parse(fs.readFileSync(path.join(siteRoot, 'src/data/outbound-domains.json'), 'utf-8')) as {
-          domains: Record<string, { class: string }>;
-        };
-        const classes = new Map(Object.entries(store.domains).map(([d, e]) => [d.replace(/^www\./, '').toLowerCase(), e.class]));
+        const classify = outboundClassifier(
+          JSON.parse(fs.readFileSync(path.join(siteRoot, 'src/data/outbound-domains.json'), 'utf-8')) as OutboundDomainStore,
+        );
         const outDir = fileURLToPath(dir);
         let files = 0;
         let anchors = 0;
@@ -57,13 +57,7 @@ export function outboundLinkRel({ root }: OutboundLinkRelOptions): AstroIntegrat
           const html = original.replace(/<a\b([^>]*)>/gi, (tag, attrs: string) => {
             const href = attrs.match(/href\s*=\s*"([^"]*)"/i)?.[1] ?? attrs.match(/href\s*=\s*'([^']*)'/i)?.[1];
             if (!href || !/^https?:\/\//i.test(href)) return tag;
-            let host: string;
-            try {
-              host = new URL(href).hostname.toLowerCase().replace(/^www\./, '');
-            } catch {
-              return tag;
-            }
-            const cls = classes.get(host) ?? 'other';
+            const cls = classify(href);
             if (cls !== 'competitor' && cls !== 'affiliate') return tag;
             anchors++;
             const tokens: string[] = [];

package/src/schema/events.ts

@@ -1,5 +1,6 @@
 import { createPersonSchema } from './context.ts';
-import { geoCoordinates, postalAddress, type AddressPolicy } from './values.ts';
+import { offer } from './nodes.ts';
+import { geoCoordinates, isFreeEntry, parsePriceFromString, postalAddress, type AddressPolicy } from './values.ts';
 import type { JsonLdNode, SchemaBuilder, SchemaContext } from './types.ts';
 
 /** Where events take place and who runs them; every value is the site's. */
@@ -15,17 +16,21 @@ export interface EventPolicy {
 }
 
 function eventPrice(data: Record<string, any>): { isFree: boolean | undefined; price: number | null } {
-  const isFree = data.tags?.includes('free') || data.price?.toLowerCase().includes('free');
-  const priceMatch = data.price?.match(/(\d+)/);
-  return { isFree, price: isFree ? 0 : (priceMatch ? parseFloat(priceMatch[1]) : null) };
+  const isFree = isFreeEntry(data);
+  return { isFree, price: isFree ? 0 : parsePriceFromString(data.price) };
 }
 
-// Offers open three months before the start date.
-function validFrom(startDate: string | undefined): string | null {
+/** Offers open three months before the start date, in UTC; a day the target month lacks clamps to its last day. */
+function offerValidFrom(startDate: string | undefined): string | null {
   if (!startDate) return null;
-  const from = new Date(new Date(startDate));
-  from.setMonth(from.getMonth() - 3);
-  return from.toISOString();
+  const start = new Date(startDate);
+  const year = start.getUTCFullYear();
+  const month = start.getUTCMonth() - 3;
+  const lastDay = new Date(Date.UTC(year, month + 1, 0)).getUTCDate();
+  return new Date(Date.UTC(
+    year, month, Math.min(start.getUTCDate(), lastDay),
+    start.getUTCHours(), start.getUTCMinutes(), start.getUTCSeconds(), start.getUTCMilliseconds(),
+  )).toISOString();
 }
 
 function eventLocation(policy: EventPolicy, data: Record<string, any>): JsonLdNode | undefined {
@@ -43,6 +48,38 @@ function eventLocation(policy: EventPolicy, data: Record<string, any>): JsonLdNo
 const EVENT_STATUS = (rescheduled: unknown) => (rescheduled ? 'https://schema.org/EventRescheduled' : 'https://schema.org/EventScheduled');
 const OFFLINE = 'https://schema.org/OfflineEventAttendanceMode';
 
+interface EventNodeParts {
+  isFree: boolean | undefined;
+  organizer: JsonLdNode;
+  offers: JsonLdNode | JsonLdNode[] | undefined;
+  /** Keys placed after the image. */
+  head?: JsonLdNode;
+  /** Keys placed last. */
+  tail?: JsonLdNode;
+}
+
+/** An Event node: its dates, status, attendance mode, free entry, location, organizer, performer and offers. */
+function eventNode(ctx: SchemaContext, policy: EventPolicy, data: Record<string, any>, parts: EventNodeParts): JsonLdNode {
+  return {
+    '@type': 'Event',
+    name: data.name,
+    description: data.description,
+    image: ctx.resolveImageUrl(data.image, data.slug),
+    ...parts.head,
+    startDate: data.startDate || undefined,
+    endDate: data.endDate || undefined,
+    previousStartDate: data.previousStartDate || undefined,
+    eventStatus: EVENT_STATUS(data.previousStartDate),
+    eventAttendanceMode: OFFLINE,
+    isAccessibleForFree: parts.isFree,
+    location: eventLocation(policy, data),
+    organizer: parts.organizer,
+    performer: policy.performer(data),
+    offers: parts.offers,
+    ...parts.tail,
+  };
+}
+
 export interface EventOptions extends EventPolicy {
   /** Map `data.offers[]` to Offers when present (else one Offer from `price`). */
   offersArray?: boolean;
@@ -57,44 +94,19 @@ export function eventBuilder(options: EventOptions): SchemaBuilder {
   const { offersArray = false, emitEvent = () => true, articleSection = 'Events', inLanguage = 'en', currency = 'EUR' } = options;
   return (data, ctx) => {
     const { isFree, price } = eventPrice(data);
-    const from = validFrom(data.startDate);
+    const validFrom = offerValidFrom(data.startDate);
     const pageRoute = ctx.route('event', data.slug);
-    const singleOffer = price !== null ? {
-      '@type': 'Offer',
-      price,
-      priceCurrency: currency,
-      availability: 'https://schema.org/InStock',
-      url: data.officialWebsite || pageRoute,
-      validFrom: from,
-    } : undefined;
-
-    const event: JsonLdNode = {
-      '@type': 'Event',
-      name: data.name,
-      description: data.description,
-      image: ctx.resolveImageUrl(data.image, data.slug),
-      startDate: data.startDate || undefined,
-      endDate: data.endDate || undefined,
-      previousStartDate: data.previousStartDate || undefined,
-      eventStatus: EVENT_STATUS(data.previousStartDate),
-      eventAttendanceMode: OFFLINE,
-      isAccessibleForFree: isFree,
-      location: eventLocation(options, data),
+    const offers = offersArray && (data.offers?.length ?? 0) > 0
+      ? data.offers.map((o: { price: number; priceCurrency?: string; url?: string; availability?: string }) => offer(
+        o.price, o.priceCurrency || currency, { availability: o.availability || undefined, url: o.url || data.officialWebsite || pageRoute, validFrom },
+      ))
+      : price !== null ? offer(price, currency, { url: data.officialWebsite || pageRoute, validFrom }) : undefined;
+    const event = eventNode(ctx, options, data, {
+      isFree,
       organizer: options.organizer(data),
-      performer: options.performer(data),
-      offers: offersArray && (data.offers?.length ?? 0) > 0
-        ? data.offers.map((o: { price: number; priceCurrency?: string; url?: string; availability?: string }) => ({
-          '@type': 'Offer',
-          price: o.price,
-          priceCurrency: o.priceCurrency || currency,
-          availability: `https://schema.org/${o.availability || 'InStock'}`,
-          url: o.url || data.officialWebsite || pageRoute,
-          validFrom: from,
-        }))
-        : singleOffer,
-      mainEntityOfPage: { '@id': ctx.pageUrl },
-      url: pageRoute,
-    };
+      offers,
+      tail: { mainEntityOfPage: { '@id': ctx.pageUrl }, url: pageRoute },
+    });
 
     const author = ctx.resolveAuthor(data.author);
     const article: JsonLdNode = {
@@ -132,9 +144,6 @@ export function eventItemListBuilder(options: EventItemListOptions): SchemaBuild
     name: data.name,
     numberOfItems: data.items?.length || 0,
     itemListElement: data.items?.map((item: any) => {
-      const { isFree, price } = eventPrice(item);
-      const from = validFrom(item.startDate);
-      const performer = options.performer(item);
       if (!isEvent(item)) {
         return {
           '@type': 'ListItem',
@@ -142,33 +151,18 @@ export function eventItemListBuilder(options: EventItemListOptions): SchemaBuild
           item: { '@type': 'WebPage', name: item.name, description: item.description, url: ctx.abs(item.url) },
         };
       }
+      const { isFree, price } = eventPrice(item);
       return {
         '@type': 'ListItem',
         position: item.position,
-        item: {
-          '@type': 'Event',
-          name: item.name,
-          description: item.description,
-          image: ctx.resolveImageUrl(item.image, item.slug),
-          url: ctx.abs(item.url),
-          startDate: item.startDate,
-          endDate: item.endDate,
-          previousStartDate: item.previousStartDate || undefined,
-          eventStatus: EVENT_STATUS(item.previousStartDate),
-          eventAttendanceMode: OFFLINE,
-          isAccessibleForFree: isFree,
-          location: eventLocation(options, item),
+        item: eventNode(ctx, options, item, {
+          head: { url: ctx.abs(item.url) },
+          isFree,
           organizer: options.itemOrganizer(item),
-          performer,
-          offers: price !== null ? {
-            '@type': 'Offer',
-            price,
-            priceCurrency: currency,
-            availability: 'https://schema.org/InStock',
-            url: item.officialWebsite || ctx.route('event', item.slug),
-            validFrom: from,
-          } : undefined,
-        },
+          offers: price !== null ? offer(price, currency, {
+            url: item.officialWebsite || ctx.route('event', item.slug), validFrom: offerValidFrom(item.startDate),
+          }) : undefined,
+        }),
       };
     }),
   });

package/src/schema/index.ts

@@ -8,7 +8,7 @@ export {
   withAuthorPersonSchema,
 } from './context.ts';
 export {
-  parsePriceFromString, cleanStreetAddress, normalizePriceRange, normalizeHotelPriceRange, postalCodeOf,
+  parsePriceFromString, isFreeEntry, cleanStreetAddress, normalizePriceRange, normalizeHotelPriceRange, postalCodeOf,
   dataAddressPolicy, postalAddress, geoCoordinates, aggregateRating,
 } from './values.ts';
 export type { AddressPolicy, PostalAddressParts } from './values.ts';
@@ -17,6 +17,10 @@ export {
   generateOpeningHours, parseHoursString, hoursStringOpenDays,
 } from './hours.ts';
 export type { DayKey, OpeningHoursInput, OpeningHoursBucket } from './hours.ts';
+export { renderSchemaPolicy } from './policy.ts';
+export type { SchemaPolicy } from './policy.ts';
+export { offer, placeNode, siteOrganizationNode, siteWebsiteNode } from './nodes.ts';
+export type { OfferFields, SiteNodeFields, OrganizationLogo } from './nodes.ts';
 export { buildBreadcrumbList, buildWebPageNode, assembleGraph, finalizeGraph } from './graph.ts';
 export type { BreadcrumbInput, PageInput, AssembleOptions } from './graph.ts';
 export {

package/src/schema/nodes.ts

@@ -0,0 +1,84 @@
+import { withAuthorPersonSchema } from './context.ts';
+import type { JsonLdNode, SchemaContext } from './types.ts';
+
+export interface OfferFields {
+  /** schema.org ItemAvailability name. */
+  availability?: string;
+  url?: string;
+  validFrom?: string | null;
+  description?: string;
+}
+
+/** An Offer; `url`, `validFrom` and `description` follow in the order given. */
+export function offer(price: number | null, currency: string, { availability = 'InStock', ...rest }: OfferFields = {}): JsonLdNode {
+  return { '@type': 'Offer', price, priceCurrency: currency, availability: `https://schema.org/${availability}`, ...rest };
+}
+
+/**
+ * An entity page's node, preceded by its author's Person: type, name, description and image, then `fields` in their
+ * order, then `mainEntityOfPage` and the `route` URL. A field named `image` replaces the resolved image in place.
+ */
+export function placeNode(
+  ctx: SchemaContext,
+  data: Record<string, any>,
+  type: string | string[],
+  route: string,
+  fields: JsonLdNode,
+): JsonLdNode | JsonLdNode[] {
+  return withAuthorPersonSchema(ctx, {
+    '@type': type,
+    name: data.name,
+    description: data.description,
+    image: ctx.resolveImageUrl(data.image, data.slug),
+    ...fields,
+    mainEntityOfPage: { '@id': ctx.pageUrl },
+    url: ctx.route(route, data.slug),
+  }, data.author);
+}
+
+export interface SiteNodeFields {
+  name: string;
+  description: string;
+}
+
+export interface OrganizationLogo {
+  path: string;
+  width?: number;
+  height?: number;
+}
+
+/** The base graph's Organization; `extra` (sameAs, knowsAbout, …) follows the description. */
+export function siteOrganizationNode(
+  ctx: SchemaContext,
+  { name, description }: SiteNodeFields,
+  logo: OrganizationLogo = { path: '/favicon.svg' },
+  extra: JsonLdNode = {},
+): JsonLdNode {
+  const logoUrl = ctx.abs(logo.path);
+  return {
+    '@type': 'Organization',
+    '@id': ctx.orgId,
+    name,
+    url: ctx.siteBaseUrl,
+    logo: {
+      '@type': 'ImageObject', url: logoUrl, contentUrl: logoUrl,
+      ...(logo.width && { width: logo.width }), ...(logo.height && { height: logo.height }),
+    },
+    description,
+    ...extra,
+  };
+}
+
+/** The base graph's WebSite, published by the Organization; `extra` (a SearchAction, …) follows. */
+export function siteWebsiteNode(ctx: SchemaContext, { name, description }: SiteNodeFields, extra: JsonLdNode = {}): JsonLdNode {
+  return {
+    '@type': 'WebSite',
+    '@id': ctx.websiteId,
+    name,
+    description,
+    url: ctx.siteBaseUrl,
+    inLanguage: 'en',
+    publisher: { '@id': ctx.orgId },
+    ...extra,
+  };
+}

package/src/schema/places.ts

@@ -1,5 +1,5 @@
-import { withAuthorPersonSchema } from './context.ts';
 import { generateOpeningHours } from './hours.ts';
+import { offer, placeNode } from './nodes.ts';
 import {
   aggregateRating, geoCoordinates, normalizeHotelPriceRange, parsePriceFromString, postalAddress, postalCodeOf,
   type AddressPolicy,
@@ -17,10 +17,7 @@ export function hotelBuilder(options: HotelOptions): SchemaBuilder {
   const { address, defaultCheckinTime = '14:00', defaultCheckoutTime = '12:00' } = options;
   return (data, ctx) => {
     const imageUrl = ctx.resolveImageUrl(data.image, data.slug);
-    return withAuthorPersonSchema(ctx, {
-      '@type': 'Hotel',
-      name: data.name,
-      description: data.description,
+    return placeNode(ctx, data, 'Hotel', 'hotel', {
       image: imageUrl ? { '@type': 'ImageObject', url: imageUrl } : undefined,
       address: postalAddress(address, data, { street: data.address, postalCode: postalCodeOf(data) }),
       geo: geoCoordinates(data.coordinates),
@@ -37,9 +34,7 @@ export function hotelBuilder(options: HotelOptions): SchemaBuilder {
       checkoutTime: data.checkoutTime || defaultCheckoutTime,
       openingHoursSpecification: generateOpeningHours(data.openingHours || { alwaysOpen: true }),
       sameAs: data.website ? [data.website] : undefined,
-      mainEntityOfPage: { '@id': ctx.pageUrl },
-      url: ctx.route('hotel', data.slug),
-    }, data.author);
+    });
   };
 }
 
@@ -56,11 +51,7 @@ export interface ActivityOptions {
 /** TouristAttraction at route `activity`; the street falls back to `meetingPoint`. */
 export function activityBuilder(options: ActivityOptions): SchemaBuilder {
   const { address, touristType = 'Cultural', defaultLanguages, offers = false, currency = 'EUR' } = options;
-  return (data, ctx) => withAuthorPersonSchema(ctx, {
-    '@type': 'TouristAttraction',
-    name: data.name,
-    description: data.description,
-    image: ctx.resolveImageUrl(data.image, data.slug),
+  return (data, ctx) => placeNode(ctx, data, 'TouristAttraction', 'activity', {
     address: postalAddress(address, data, { street: data.address || data.meetingPoint, postalCode: postalCodeOf(data) }),
     geo: geoCoordinates(data.coordinates),
     touristType,
@@ -69,15 +60,8 @@ export function activityBuilder(options: ActivityOptions): SchemaBuilder {
     availableLanguage: data.languages || defaultLanguages,
     telephone: data.phone,
     aggregateRating: aggregateRating(data),
-    offers: offers && data.priceFrom !== undefined ? {
-      '@type': 'Offer',
-      price: data.priceFrom,
-      priceCurrency: currency,
-      availability: 'https://schema.org/InStock',
-    } : undefined,
-    mainEntityOfPage: { '@id': ctx.pageUrl },
-    url: ctx.route('activity', data.slug),
-  }, data.author);
+    offers: offers && data.priceFrom !== undefined ? offer(data.priceFrom, currency) : undefined,
+  });
 }
 
 export interface TouristTripOptions {
@@ -86,22 +70,15 @@ export interface TouristTripOptions {
   currency?: string;
 }
 
-/** A free self-guided TouristTrip at route `walk`, its stops as the itinerary. */
+/**
+ * A free self-guided TouristTrip at route `walk`, its stops as the itinerary.
+ * @deprecated Tourism-only: import `touristTripBuilder` from `@sarimarcus/content-sites-tourism/schema` (SLA-2918).
+ */
 export function touristTripBuilder(options: TouristTripOptions = {}): SchemaBuilder {
   const { touristType = 'Cultural', offerDescription = 'Self-guided walking tour — free', currency = 'EUR' } = options;
-  return (data, ctx) => withAuthorPersonSchema(ctx, {
-    '@type': 'TouristTrip',
-    name: data.name,
-    description: data.description,
-    image: ctx.resolveImageUrl(data.image, data.slug),
+  return (data, ctx) => placeNode(ctx, data, 'TouristTrip', 'walk', {
     touristType: data.theme || touristType,
-    offers: {
-      '@type': 'Offer',
-      price: 0,
-      priceCurrency: currency,
-      availability: 'https://schema.org/InStock',
-      description: offerDescription,
-    },
+    offers: offer(0, currency, { description: offerDescription }),
     itinerary: {
       '@type': 'ItemList',
       numberOfItems: data.stops?.length || 0,
@@ -117,7 +94,5 @@ export function touristTripBuilder(options: TouristTripOptions = {}): SchemaBuil
         },
       })),
     },
-    mainEntityOfPage: { '@id': ctx.pageUrl },
-    url: ctx.route('walk', data.slug),
-  }, data.author);
+  });
 }

package/src/schema/policy.ts

@@ -0,0 +1,25 @@
+import { createSchemaContext } from './context.ts';
+import { assembleGraph, finalizeGraph, type AssembleOptions, type PageInput } from './graph.ts';
+import type { JsonLdNode, SchemaBuilders, SchemaContext, SchemaContextInput, SchemaEntry } from './types.ts';
+
+/** A site's JSON-LD policy: its context options, base nodes, builders and graph hooks. */
+export interface SchemaPolicy {
+  context?: Partial<SchemaContextInput>;
+  nodes(ctx: SchemaContext): { organization: JsonLdNode; website: JsonLdNode };
+  builders: SchemaBuilders;
+  hooks?(ctx: SchemaContext, entries: SchemaEntry[]): Pick<AssembleOptions, 'beforeEntries' | 'afterEntries'>;
+}
+
+/**
+ * One page's finalised JSON-LD under a site policy: context, base nodes, entries, hooks. The site adapter and the
+ * factory schema goldens both render through this, so the goldens test the wiring that ships.
+ */
+export function renderSchemaPolicy(input: SchemaContextInput, policy: SchemaPolicy, page: PageInput): JsonLdNode {
+  const ctx = createSchemaContext({ ...input, ...policy.context });
+  return finalizeGraph(ctx, assembleGraph(ctx, {
+    ...policy.nodes(ctx),
+    builders: policy.builders,
+    ...page,
+    ...policy.hooks?.(ctx, page.entries),
+  }));
+}

package/src/schema/values.ts

@@ -8,6 +8,14 @@ export function parsePriceFromString(priceStr: string | undefined): number | nul
   return match ? parseFloat(match[1]) : null;
 }
 
+/**
+ * Free entry: a `free` tag, or "free" in the price text (`price` for events, `fees` for places). `undefined` when
+ * neither is present, so the key drops out of the JSON-LD.
+ */
+export function isFreeEntry(data: Record<string, any>, field: 'price' | 'fees' = 'price'): boolean | undefined {
+  return data.tags?.includes('free') || data[field]?.toLowerCase().includes('free');
+}
+
 /** Street and number only: drops postal code, city and country, and a second part that is a district or postcode. */
 export function cleanStreetAddress(fullAddress: string | undefined): string {
   if (!fullAddress) return '';

package/src/url/index.ts

@@ -6,3 +6,5 @@ export { buildImageMap, keyBySlug } from './imageMap.ts';
 export { articleFeedItem } from './feed.ts';
 export type { FeedArticle, FeedItem } from './feed.ts';
 export { pageTypeOf } from './pageType.ts';
+export { outboundClassifier, outboundHostKey } from './outbound.ts';
+export type { OutboundDomainStore } from './outbound.ts';

package/src/url/outbound.ts

@@ -0,0 +1,27 @@
+/** The outbound-domains store as synced into each site (`src/data/outbound-domains.json`). */
+export interface OutboundDomainStore {
+  domains: Record<string, { class: string }>;
+}
+
+/** Host key of the store: lowercase, without `www.`. */
+export function outboundHostKey(host: string): string {
+  return host.toLowerCase().replace(/^www\./, '');
+}
+
+/**
+ * URL → its Rule 38 class (`competitor`, `affiliate`, `official`, …) from the store, or a plain host → class map;
+ * `other` for an unlisted host or a URL that does not parse. Lookup only: each consumer decides what a class renders.
+ */
+export function outboundClassifier(store: OutboundDomainStore | Record<string, string>): (url: string) => string {
+  const entries = 'domains' in store && typeof store.domains === 'object'
+    ? Object.entries((store as OutboundDomainStore).domains).map(([d, e]) => [d, e.class] as const)
+    : Object.entries(store as Record<string, string>);
+  const classes = new Map(entries.map(([d, c]) => [outboundHostKey(d), c]));
+  return (url) => {
+    try {
+      return classes.get(outboundHostKey(new URL(url).hostname)) ?? 'other';
+    } catch {
+      return 'other';
+    }
+  };
+}