@expofp/config 3.11.10

package/dist/lib/local-storage-codec.d.ts

@@ -0,0 +1,44 @@
+/**
+ * localStorage codec — value ⇄ key/value store (`localStorage`), with coercion
+ * driven by an ordinary Zod schema (no `z.coerce` anywhere):
+ *
+ *   parseFromStorage(schema, storage)   store → validated value
+ *   writeToStorage(value, storage)      value → store
+ *   clearStorage(schema, storage)       remove the schema's keys
+ *
+ * Key layout — one `efp-`-prefixed key per top-level field, devtools-readable
+ * and consistent with the app's existing keys (`efp-locale`, `efp-telemetry`):
+ *   • SCALAR fields (boolean/number/string/enum) → plain string value:
+ *        efp-enableExperimentalMaplibre = "true"
+ *        efp-debugPattern               = "map:*"
+ *   • OBJECT / ARRAY fields → JSON under one key:
+ *        efp-bookmarks = ["a","b"]
+ *
+ * On decode, each scalar is coerced to its declared type by introspecting the
+ * schema (`z.toJSONSchema`); objects/arrays are JSON-parsed. Only prefixed keys
+ * are ever read or written — the rest of the store is never touched. The
+ * top-level schema must be an object.
+ */
+import type * as z from 'zod';
+/** The subset of the DOM `Storage` API used here — `window.localStorage` satisfies it. */
+export interface StorageLike {
+    getItem(key: string): string | null;
+    setItem(key: string, value: string): void;
+    removeItem(key: string): void;
+}
+export interface StorageCodecOptions {
+    /** Key prefix. Default `'efp-'`. */
+    prefix?: string;
+}
+/** The SDK's localStorage key prefix (`efp-locale`, `efp-telemetry`, …). */
+export declare const DEFAULT_STORAGE_PREFIX = "efp-";
+export declare function parseFromStorage<S extends z.ZodType>(schema: S, storage: StorageLike, options?: StorageCodecOptions): z.infer<S>;
+export declare function safeParseFromStorage<S extends z.ZodType>(schema: S, storage: StorageLike, options?: StorageCodecOptions): z.ZodSafeParseResult<z.core.output<S>>;
+export declare function writeToStorage(value: object, storage: StorageLike, options?: StorageCodecOptions): void;
+/** Remove every key this schema owns (its prefixed keys) from the store. */
+export declare function clearStorage(schema: z.ZodType, storage: StorageLike, options?: StorageCodecOptions): void;
+/** A tiny in-memory `StorageLike` for tests, SSR, or when there is no `localStorage`. */
+export declare function createMemoryStorage(initial?: Record<string, string>): StorageLike & {
+    dump(): Record<string, string>;
+};
+//# sourceMappingURL=local-storage-codec.d.ts.map

package/dist/lib/local-storage-codec.js

@@ -0,0 +1,76 @@
+import { coerceScalar, toJsonSchema } from './json-schema.js';
+/** The SDK's localStorage key prefix (`efp-locale`, `efp-telemetry`, …). */
+export const DEFAULT_STORAGE_PREFIX = 'efp-';
+/* ── Decode: store → value ─────────────────────────────────────────────────── */
+export function parseFromStorage(schema, storage, options = {}) {
+    return schema.parse(readRecord(schema, storage, options.prefix ?? DEFAULT_STORAGE_PREFIX));
+}
+export function safeParseFromStorage(schema, storage, options = {}) {
+    return schema.safeParse(readRecord(schema, storage, options.prefix ?? DEFAULT_STORAGE_PREFIX));
+}
+function readRecord(schema, storage, prefix) {
+    const record = {};
+    for (const [field, node] of Object.entries(toJsonSchema(schema).properties ?? {})) {
+        const raw = storage.getItem(prefix + field);
+        if (raw === null) {
+            continue; // absent → let the schema apply its default / optionality
+        }
+        record[field] = readValue(node, raw);
+    }
+    return record;
+}
+function readValue(node, raw) {
+    if (node.type === 'object' || node.type === 'array' || node.anyOf || node.oneOf) {
+        try {
+            return JSON.parse(raw);
+        }
+        catch {
+            return raw; // malformed JSON → hand the string to schema.parse for a clear error
+        }
+    }
+    return coerceScalar(raw, node.type);
+}
+/* ── Encode: value → store (schema-agnostic) ───────────────────────────────── */
+export function writeToStorage(value, storage, options = {}) {
+    const prefix = options.prefix ?? DEFAULT_STORAGE_PREFIX;
+    for (const [field, item] of Object.entries(value)) {
+        const key = prefix + field;
+        if (item === undefined || item === null) {
+            storage.removeItem(key);
+        }
+        else if (typeof item === 'object') {
+            storage.setItem(key, JSON.stringify(item)); // objects & arrays → JSON
+        }
+        else {
+            storage.setItem(key, String(item)); // scalars → plain string
+        }
+    }
+}
+/** Remove every key this schema owns (its prefixed keys) from the store. */
+export function clearStorage(schema, storage, options = {}) {
+    const prefix = options.prefix ?? DEFAULT_STORAGE_PREFIX;
+    for (const field of Object.keys(toJsonSchema(schema).properties ?? {})) {
+        storage.removeItem(prefix + field);
+    }
+}
+/* ── Helpers ───────────────────────────────────────────────────────────────── */
+/** A tiny in-memory `StorageLike` for tests, SSR, or when there is no `localStorage`. */
+export function createMemoryStorage(initial = {}) {
+    const map = new Map(Object.entries(initial));
+    return {
+        getItem: (key) => (map.has(key) ? (map.get(key)) : null),
+        setItem: (key, value) => {
+            map.set(key, value);
+        },
+        removeItem: (key) => {
+            map.delete(key);
+        },
+        dump: () => {
+            const out = {};
+            map.forEach((value, key) => {
+                out[key] = value;
+            });
+            return out;
+        },
+    };
+}

package/dist/lib/normalize-fp-svg.d.ts

@@ -0,0 +1,26 @@
+import type { FpSvgLayerJs } from '@expofp/schema';
+/**
+ * Fold the layer-suffixed drawing globals onto the canonical keys, in place.
+ *
+ * `fp.svg.<layerName>.js` files come in two converter generations: older ones
+ * chain-assign every drawing global under both names (`window['__fpHall'] =
+ * window['__fp'] = …`), newer ones emit ONLY the suffixed globals
+ * (`window['__fpBooth'] = …` — the chain had every layer script clobber the
+ * shared `window.__fp`). The schemas and the floorplan know only the plain
+ * `__fp`/`__fpPaths` keys, so the loader folds the alias onto them on the
+ * payload's own copy, before the resource walk — the `svgAsset` href rewrite
+ * then covers a folded drawing like a plain one. The folded values skip the
+ * (opt-in) schema validation, which ran before the fold — the same trust the
+ * untouched alias keys always had.
+ *
+ * The eager `fp.svg.js` needs no fold: every runtime generation reads its
+ * plain `__fp`, so converters keep emitting it there. A resolved offline
+ * `fp.svg.<layerName>.json` may still carry only alias keys (serialization
+ * re-mints cold refs without the fold), and folds here at load like a live
+ * script.
+ *
+ * Legacy-format shim: retires with the window-assigning `.js` payloads once
+ * the platform serves resolved JSON documents.
+ */
+export declare function normalizeFpSvgLayerAliases(payload: FpSvgLayerJs, layerName: string): void;
+//# sourceMappingURL=normalize-fp-svg.d.ts.map

package/dist/lib/normalize-fp-svg.js

@@ -0,0 +1,36 @@
+/**
+ * Fold the layer-suffixed drawing globals onto the canonical keys, in place.
+ *
+ * `fp.svg.<layerName>.js` files come in two converter generations: older ones
+ * chain-assign every drawing global under both names (`window['__fpHall'] =
+ * window['__fp'] = …`), newer ones emit ONLY the suffixed globals
+ * (`window['__fpBooth'] = …` — the chain had every layer script clobber the
+ * shared `window.__fp`). The schemas and the floorplan know only the plain
+ * `__fp`/`__fpPaths` keys, so the loader folds the alias onto them on the
+ * payload's own copy, before the resource walk — the `svgAsset` href rewrite
+ * then covers a folded drawing like a plain one. The folded values skip the
+ * (opt-in) schema validation, which ran before the fold — the same trust the
+ * untouched alias keys always had.
+ *
+ * The eager `fp.svg.js` needs no fold: every runtime generation reads its
+ * plain `__fp`, so converters keep emitting it there. A resolved offline
+ * `fp.svg.<layerName>.json` may still carry only alias keys (serialization
+ * re-mints cold refs without the fold), and folds here at load like a live
+ * script.
+ *
+ * Legacy-format shim: retires with the window-assigning `.js` payloads once
+ * the platform serves resolved JSON documents.
+ */
+export function normalizeFpSvgLayerAliases(payload, layerName) {
+    if (payload.__fp === undefined) {
+        const alias = payload[`__fp${layerName}`];
+        if (typeof alias === 'string')
+            payload.__fp = alias;
+    }
+    if (payload.__fpPaths === undefined) {
+        const alias = payload[`__fpPaths${layerName}`];
+        // the alias carries the same converter output as __fpPaths, just unvalidated
+        if (Array.isArray(alias))
+            payload.__fpPaths = alias;
+    }
+}

package/dist/lib/normalize-legacy-data.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Post-merge normalization of the legacy event data.
+ *
+ * Ports the floorplan's historical `data/validate-data.ts`, which mutated
+ * `window.__data` at module load. The config is now the single — and frozen —
+ * copy of that data, so the same fixes run here, inside `loadConfig`, after
+ * every layer is merged and before `deepFreeze`. The rules are kept verbatim
+ * (including the expo-specific ones marked for removal); only the opt-in
+ * console diagnostics were dropped — the schema parse validates instead.
+ */
+import { type Config } from '@expofp/schema';
+export declare function normalizeLegacyData(config: Config, legacyDataUrlBase?: string): void;
+//# sourceMappingURL=normalize-legacy-data.d.ts.map

package/dist/lib/normalize-legacy-data.js

@@ -0,0 +1,90 @@
+import { withVariantUrl } from './resource-urls.js';
+/** One-off promo for the `expo` event — exhibitor ids forced to advertise. */
+const EXPO_EXPO_ADS = [2567, 2704, 2681, 2592, 2740, 2709, 2482, 2609, 2734, 2696, 2840, 2566, 2736];
+export function normalizeLegacyData(config, legacyDataUrlBase) {
+    const expo = config.expo;
+    const booths = (config.booths ?? []);
+    const exhibitors = (config.exhibitors ?? []);
+    // data.js may carry explicit nulls (the layer merge skips only `undefined`),
+    // and the effective config's arrays are non-nullable — the fallbacks must
+    // land back on the config, not just in the locals above.
+    config.booths = booths;
+    config.exhibitors = exhibitors;
+    config.categories ??= [];
+    // free plans force the ad and disable featured placement
+    if (config.free) {
+        config.noFeatured = true;
+        config.expoFpAd = true;
+    }
+    // an unexpired trial marks the event as a trial
+    if (config.trialExpiresAt) {
+        const expires = new Date(config.trialExpiresAt).getTime();
+        if (Date.now() < expires) {
+            config.isTrial = true;
+        }
+    }
+    // temporary workaround for invalid data.js
+    if (exhibitors.length > 0) {
+        for (const booth of booths) {
+            delete booth.reserved;
+        }
+    }
+    // exhibitor logos: always the object form on the effective config — the
+    // legacy string form (already absolutized) converts here, the platform's
+    // pre-scaled __small/__tiny siblings becoming explicit variant URLs
+    for (const exhibitor of exhibitors) {
+        if (typeof exhibitor.logo === 'string') {
+            exhibitor.logo = exhibitor.logo
+                ? {
+                    url: exhibitor.logo,
+                    smallUrl: withVariantUrl(exhibitor.logo, '__small'),
+                    tinyUrl: withVariantUrl(exhibitor.logo, '__tiny'),
+                }
+                : { url: exhibitor.logo };
+        }
+    }
+    // some data fixes (expo-specific will be removed)
+    if (!config.logo && expo === 'expo')
+        config.logo = legacyAssetUrl('../logo.svg', legacyDataUrlBase);
+    if (!config.logo)
+        config.logo = legacyAssetUrl(`../${expo}-logo.png`, legacyDataUrlBase);
+    if (!config.homeUrl && expo === 'jtrade19')
+        config.homeUrl = 'https://www.jtrade.co.uk/';
+    // this is permanent
+    if (!config.boothTerm)
+        config.boothTerm = 'Booth';
+    if (!config.exhibitorTermPlural)
+        config.exhibitorTermPlural = 'Exhibitors';
+    if (expo === 'expo') {
+        exhibitors
+            .filter((x) => x.logo?.url && EXPO_EXPO_ADS.includes(x.id))
+            .forEach((x) => (x.advertise = true));
+    }
+    // convert obsolete fields
+    for (const booth of booths) {
+        if (!booth.special) {
+            if (typeof booth.onHold === 'undefined')
+                booth.onHold = booth.isOnHold;
+            if (typeof booth.availColor === 'undefined')
+                booth.availColor = booth.availableColor;
+            if (typeof booth.type === 'undefined')
+                booth.type = booth.boothTypeName;
+        }
+        booth.exhibitors = booth.exhibitors ?? [];
+    }
+    for (const exhibitor of exhibitors) {
+        if (typeof exhibitor.featured === 'undefined')
+            exhibitor.featured = exhibitor.isFeatured;
+        if (typeof exhibitor.email === 'undefined')
+            exhibitor.email = exhibitor.publicEmail;
+        exhibitor.categories = exhibitor.categories ?? [];
+    }
+    // disable featured placement for free plans
+    if (config.noFeatured) {
+        exhibitors.forEach((e) => (e.featured = false));
+    }
+}
+/** The historical logo fallbacks are data-dir-relative paths — rebase them onto the data directory. */
+function legacyAssetUrl(path, base) {
+    return base ? `${base.replace(/\/+$/, '')}/${path}` : path;
+}

package/dist/lib/rebooking.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Rebooking layer of `loadConfig`.
+ *
+ * When a rebooking token is present (page query `?rt=…`, retained in
+ * `sessionStorage` across in-session navigations), fetch the per-exhibitor
+ * rebooking state from the platform and merge it into the not-yet-frozen
+ * config: `exhibitors[].rebookingState` / `rebookingNote` plus the
+ * `isRebooking` flag. Ported from the floorplan loader's init-time merge so
+ * the frozen config stays the single, complete copy of the event data. The
+ * floorplan keeps its own `tools/rebookingUrl.ts` helpers for UI *actions*
+ * against the same API (e.g. `set-rebooking-state`).
+ *
+ * Without a token — every ordinary visitor, and Node callers that pass no
+ * `url` — this is a synchronous no-op apart from `isRebooking = false`.
+ */
+import { type Config } from '@expofp/schema';
+/** Merge rebooking state into `config` when a token is present. Never throws. */
+export declare function applyRebookingData(config: Config, url: string | undefined): Promise<void>;
+//# sourceMappingURL=rebooking.d.ts.map

package/dist/lib/rebooking.js

@@ -0,0 +1,48 @@
+const TOKEN_KEY = 'rt';
+const REBOOKING_API_ORIGIN = 'https://app.expofp.com/';
+/** Merge rebooking state into `config` when a token is present. Never throws. */
+export async function applyRebookingData(config, url) {
+    try {
+        const token = getRebookingToken(url);
+        if (!token) {
+            config.isRebooking = false;
+            return;
+        }
+        retainRebookingToken(token);
+        const apiUrl = new URL('api/rebooking-data', REBOOKING_API_ORIGIN);
+        apiUrl.searchParams.set(TOKEN_KEY, token);
+        apiUrl.searchParams.set('expoKey', config.expo);
+        const resp = await fetch(apiUrl.href);
+        if (resp.ok) {
+            const rebooking = (await resp.json());
+            mergeRebookingState(config, rebooking.exhibitors ?? []);
+        }
+        config.isRebooking = resp.ok;
+    }
+    catch (error) {
+        // parity with the old loader merge: report and continue without rebooking
+        console.error(error);
+    }
+}
+/** Token from the page query (same decode the floorplan helpers use), else the retained one. */
+function getRebookingToken(url) {
+    const fromQuery = url ? new URLSearchParams(decodeURIComponent(url)).get(TOKEN_KEY) : null;
+    if (fromQuery)
+        return fromQuery;
+    return typeof sessionStorage !== 'undefined' ? sessionStorage.getItem(TOKEN_KEY) : null;
+}
+function retainRebookingToken(token) {
+    if (typeof sessionStorage !== 'undefined') {
+        sessionStorage.setItem(TOKEN_KEY, token);
+    }
+}
+function mergeRebookingState(config, incoming) {
+    const exhibitors = config.exhibitors ?? [];
+    for (const rebooking of incoming) {
+        const exhibitor = exhibitors.find((x) => x.id === rebooking.id);
+        if (exhibitor) {
+            exhibitor.rebookingState = rebooking.rebookingState;
+            exhibitor.rebookingNote = rebooking.rebookingNote;
+        }
+    }
+}

package/dist/lib/resource-urls.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Internal URL/text helpers for the schema-tagged resource kinds. Nothing here
+ * is public API — consumers only ever see the effects: `resolve(ref, {
+ * schema })` settles documents with absolute resource URLs, and
+ * `visitResources` enumerates/rewrites them.
+ */
+/** Prepend `baseUrl` to a relative path so it becomes a full URL; absolute paths pass through. */
+export declare function toAbsoluteUrl(path: string, baseUrl: string): string;
+/**
+ * Scheme-qualified (`https:`, `data:`, `blob:`…), protocol-relative
+ * (`//host/…`), or rooted (`/…` — already resolved, just host-less). Note a
+ * page-relative offline path (`host-slug/data/…`, no leading slash) is NOT
+ * absolute: it is resolved against the page at runtime, so document loads must
+ * not rebase it (see `documentRef`).
+ */
+export declare function isAbsoluteUrl(path: string): boolean;
+/** The ref's own directory — the base its document's relative paths resolve against. */
+export declare function refDirectory(ref: string): string;
+/** Every distinct `<image>` asset href in one SVG document string. */
+export declare function collectSvgImageHrefs(svg: string): string[];
+/** Rewrite every `<image>` asset href in one SVG document string. */
+export declare function rewriteSvgImageHrefs(svg: string, rewrite: (href: string) => string): string;
+/** Every distinct non-`data:` `url(…)` in one CSS text. */
+export declare function collectCssUrls(css: string): string[];
+/** Rewrite every non-`data:` `url(…)` in one CSS text. */
+export declare function rewriteCssUrls(css: string, rewrite: (url: string) => string): string;
+export interface InlinedCss {
+    css: string;
+    /** Import URLs left in place (conditional/unresolvable) — keep them verbatim, don't localize. */
+    external: Set<string>;
+}
+/**
+ * Replace every unconditional `@import` with the imported stylesheet's text.
+ *
+ * An offline copy cannot keep stylesheets as fetched files: a URL like
+ * `https://fonts.googleapis.com/css2?family=…` saves to an extension-less
+ * path that static servers refuse to serve as `text/css` (stylesheet loads
+ * enforce MIME), and the file's inner `url(…)`s would stay remote. Splicing
+ * the text into the importing CSS instead lets the ordinary `url(…)`
+ * localization pass handle every asset the import pulled in.
+ *
+ * Inner URLs of an imported sheet resolve against the *sheet's* URL, so they
+ * are rebased to absolute before splicing; nested imports recurse the same
+ * way. A conditional import (layer/supports/media) has no faithful inline
+ * form — it is kept verbatim (still network-dependent) with a warning, as is
+ * a relative href with no base to resolve against. An import cycle fails the
+ * build loudly.
+ */
+export declare function inlineCssImports(css: string, fetchText: (url: string) => string | Promise<string>, base?: string, stack?: readonly string[]): Promise<InlinedCss>;
+/** `…/name.ext?q` → `…/name<suffix>.ext?q` (query untouched). */
+export declare function withVariantUrl(url: string, suffix: string): string;
+//# sourceMappingURL=resource-urls.d.ts.map

package/dist/lib/resource-urls.js

@@ -0,0 +1,196 @@
+/**
+ * Internal URL/text helpers for the schema-tagged resource kinds. Nothing here
+ * is public API — consumers only ever see the effects: `resolve(ref, {
+ * schema })` settles documents with absolute resource URLs, and
+ * `visitResources` enumerates/rewrites them.
+ */
+/** Prepend `baseUrl` to a relative path so it becomes a full URL; absolute paths pass through. */
+export function toAbsoluteUrl(path, baseUrl) {
+    if (path === '' || isAbsoluteUrl(path)) {
+        return path;
+    }
+    return `${baseUrl.replace(/\/+$/, '')}/${path}`;
+}
+/**
+ * Scheme-qualified (`https:`, `data:`, `blob:`…), protocol-relative
+ * (`//host/…`), or rooted (`/…` — already resolved, just host-less). Note a
+ * page-relative offline path (`host-slug/data/…`, no leading slash) is NOT
+ * absolute: it is resolved against the page at runtime, so document loads must
+ * not rebase it (see `documentRef`).
+ */
+export function isAbsoluteUrl(path) {
+    return path.startsWith('/') || /^[a-z][a-z0-9+.-]*:/i.test(path);
+}
+/** The ref's own directory — the base its document's relative paths resolve against. */
+export function refDirectory(ref) {
+    const path = ref.split(/[?#]/, 1)[0];
+    return path.slice(0, path.lastIndexOf('/') + 1);
+}
+/**
+ * `[...text.matchAll(regex)]` without `String.prototype.matchAll` — the
+ * collect functions run on the boot path and the SDK still targets Chrome
+ * 66–72 WebViews (matchAll is Chrome 73+). Resets `lastIndex` up front so the
+ * shared module-const `/g` regexes cannot carry scan state between calls.
+ */
+function execAll(regex, text) {
+    const matches = [];
+    regex.lastIndex = 0;
+    for (let match = regex.exec(text); match; match = regex.exec(text)) {
+        matches.push(match);
+        if (match[0] === '')
+            regex.lastIndex++; // zero-length match must not stall the scan
+    }
+    return matches;
+}
+/* ── SVG documents (`svgAsset`) — `<image>` hrefs are asset paths ─────────── */
+const IMAGE_TAG = /<image\b[^>]*>/g;
+const HREF_ATTR = /(\b(?:xlink:)?href\s*=\s*)(?:"([^"]*)"|'([^']*)')/g;
+/** In-document (`#id`) and empty hrefs are not asset URLs. */
+function isAssetHref(href) {
+    return !!href && !href.startsWith('#');
+}
+/** Every distinct `<image>` asset href in one SVG document string. */
+export function collectSvgImageHrefs(svg) {
+    const hrefs = new Set();
+    if (!svg.includes('<image'))
+        return [];
+    for (const tag of svg.match(IMAGE_TAG) ?? []) {
+        for (const match of execAll(HREF_ATTR, tag)) {
+            const href = match[2] ?? match[3];
+            if (isAssetHref(href))
+                hrefs.add(href);
+        }
+    }
+    return [...hrefs];
+}
+/** Rewrite every `<image>` asset href in one SVG document string. */
+export function rewriteSvgImageHrefs(svg, rewrite) {
+    if (!svg.includes('<image'))
+        return svg;
+    return svg.replace(IMAGE_TAG, (tag) => tag.replace(HREF_ATTR, (match, attr, doubleQuoted, singleQuoted) => {
+        const href = doubleQuoted ?? singleQuoted ?? '';
+        if (!isAssetHref(href))
+            return match;
+        const quote = doubleQuoted !== undefined ? '"' : "'";
+        return `${attr}${quote}${rewrite(href)}${quote}`;
+    }));
+}
+/* ── CSS text (`cssAsset`) — `url(…)`s are asset paths ────────────────────── */
+const CSS_URL = /url\(\s*(['"]?)(.*?)\1\s*\)/g;
+/** Every distinct non-`data:` `url(…)` in one CSS text. */
+export function collectCssUrls(css) {
+    const urls = new Set();
+    for (const match of execAll(CSS_URL, css)) {
+        const url = match[2];
+        if (url && !url.startsWith('data:'))
+            urls.add(url);
+    }
+    return [...urls];
+}
+/** Rewrite every non-`data:` `url(…)` in one CSS text. */
+export function rewriteCssUrls(css, rewrite) {
+    return css.replace(CSS_URL, (match, quote, url) => {
+        if (!url || url.startsWith('data:'))
+            return match;
+        return `url(${quote}${rewrite(url)}${quote})`;
+    });
+}
+/* ── CSS `@import` inlining (offline serialization) ───────────────────────── */
+// One `@import` rule: `url(…)` or bare-string href, then everything up to the
+// terminating `;` (an optional layer/supports/media condition).
+const CSS_IMPORT = /@import\s+(?:url\(\s*(['"]?)(.*?)\1\s*\)|(["'])(.*?)\3)\s*([^;]*);/gi;
+/**
+ * Replace every unconditional `@import` with the imported stylesheet's text.
+ *
+ * An offline copy cannot keep stylesheets as fetched files: a URL like
+ * `https://fonts.googleapis.com/css2?family=…` saves to an extension-less
+ * path that static servers refuse to serve as `text/css` (stylesheet loads
+ * enforce MIME), and the file's inner `url(…)`s would stay remote. Splicing
+ * the text into the importing CSS instead lets the ordinary `url(…)`
+ * localization pass handle every asset the import pulled in.
+ *
+ * Inner URLs of an imported sheet resolve against the *sheet's* URL, so they
+ * are rebased to absolute before splicing; nested imports recurse the same
+ * way. A conditional import (layer/supports/media) has no faithful inline
+ * form — it is kept verbatim (still network-dependent) with a warning, as is
+ * a relative href with no base to resolve against. An import cycle fails the
+ * build loudly.
+ */
+export async function inlineCssImports(css, fetchText, base, stack = []) {
+    const external = new Set();
+    const imports = [...css.matchAll(CSS_IMPORT)];
+    const replacements = await Promise.all(imports.map(async (match) => {
+        const href = match[2] ?? match[4] ?? '';
+        const condition = match[5].trim();
+        const url = resolveImportHref(href, base);
+        if (!url || condition) {
+            if (condition) {
+                console.warn(`Keeping conditional CSS import remote: @import ${href} ${condition}`);
+            }
+            else {
+                console.warn(`Keeping unresolvable relative CSS import: @import ${href}`);
+            }
+            external.add(href);
+            return match[0];
+        }
+        if (stack.includes(url)) {
+            throw new Error(`CSS @import cycle: ${[...stack, url].join(' -> ')}`);
+        }
+        const imported = await fetchText(url);
+        // A common authoring slip is `@import url(font.ttf)` sitting beside a real
+        // `@font-face` — the browser fetches the font, fails to parse it as CSS,
+        // and the import contributes nothing (a no-op). Splicing its bytes in here
+        // would instead inject binary garbage that corrupts the whole stylesheet.
+        // Replicate the browser: drop the import. The font still loads offline via
+        // the sibling `@font-face`'s own `url(…)`, which the asset pass localizes.
+        if (!isStylesheetText(imported)) {
+            console.warn(`Dropping non-stylesheet CSS @import (not parseable as CSS): @import ${href}`);
+            return '';
+        }
+        // nested imports and relative url(…)s resolve against the imported sheet
+        const nested = await inlineCssImports(imported, fetchText, url, [...stack, url]);
+        for (const kept of nested.external) {
+            // the rebase below turns a kept rule's relative href absolute — track both forms
+            external.add(kept);
+            external.add(resolveImportHref(kept, url) ?? kept);
+        }
+        return rewriteCssUrls(nested.css, (inner) => resolveImportHref(inner, url) ?? inner);
+    }));
+    let index = 0;
+    return { css: css.replace(CSS_IMPORT, () => replacements[index++]), external };
+}
+/**
+ * Whether fetched `@import` content is a stylesheet rather than a binary asset
+ * (font/image) mistakenly targeted by `@import`. A NUL byte — abundant in every
+ * font format (TTF/OTF/WOFF/WOFF2/EOT) once decoded as text — never appears in a
+ * CSS stylesheet, so it is a precise, false-positive-free signal for binary.
+ */
+function isStylesheetText(text) {
+    return !text.includes('\u0000');
+}
+/** The href's absolute URL, or undefined when it is relative with no base to resolve against. */
+function resolveImportHref(href, base) {
+    if (!href)
+        return undefined;
+    try {
+        return base ? new URL(href, base).href : new URL(href).href;
+    }
+    catch {
+        return undefined;
+    }
+}
+/* ── Logo variants — pre-scaled sibling files by filename suffix ──────────── */
+/** `…/name.ext?q` → `…/name<suffix>.ext?q` (query untouched). */
+export function withVariantUrl(url, suffix) {
+    const [path, query] = splitOnce(url, /[?#]/);
+    const lastSlash = path.lastIndexOf('/');
+    const dir = path.slice(0, lastSlash + 1);
+    const filename = path.slice(lastSlash + 1);
+    const dot = filename.lastIndexOf('.');
+    const suffixed = dot > 0 ? `${filename.slice(0, dot)}${suffix}${filename.slice(dot)}` : `${filename}${suffix}`;
+    return `${dir}${suffixed}${query}`;
+}
+function splitOnce(value, at) {
+    const index = value.search(at);
+    return index === -1 ? [value, ''] : [value.slice(0, index), value.slice(index)];
+}

package/dist/lib/serialize-config-resources.d.ts

@@ -0,0 +1,22 @@
+import { type Config, type Manifest } from '@expofp/schema';
+import { type ResourceHandler } from './visit-resources.js';
+/**
+ * Where serialized resources go: the caller decides storage (paths, prefixes,
+ * downloads); the config decides *what* the resources are.
+ */
+export type ConfigResourceStore = ResourceHandler;
+/**
+ * Serialize a loaded config into a portable manifest: every schema-tagged
+ * asset (plain URLs, `<image>` hrefs inside the drawings, CSS `url(…)`s,
+ * pre-scaled exhibitor image variants) and every referenced payload document
+ * (drawing, layers, wayfinding graph — resolved on the fly) is handed to
+ * `store`, and the returned copy points at whatever URLs the store assigned.
+ *
+ * The legacy data directory fields are dropped — a serialized config IS the
+ * complete event data document, so a runtime consuming it derives and fetches
+ * nothing beyond the refs the store wrote.
+ */
+export declare function serializeConfigResources(config: Config, store: ConfigResourceStore, options?: {
+    signal?: AbortSignal | null;
+}): Promise<Manifest>;
+//# sourceMappingURL=serialize-config-resources.d.ts.map

package/dist/lib/serialize-config-resources.js

@@ -0,0 +1,20 @@
+import { ConfigSchema } from '@expofp/schema';
+import { visitResources } from './visit-resources.js';
+/**
+ * Serialize a loaded config into a portable manifest: every schema-tagged
+ * asset (plain URLs, `<image>` hrefs inside the drawings, CSS `url(…)`s,
+ * pre-scaled exhibitor image variants) and every referenced payload document
+ * (drawing, layers, wayfinding graph — resolved on the fly) is handed to
+ * `store`, and the returned copy points at whatever URLs the store assigned.
+ *
+ * The legacy data directory fields are dropped — a serialized config IS the
+ * complete event data document, so a runtime consuming it derives and fetches
+ * nothing beyond the refs the store wrote.
+ */
+export async function serializeConfigResources(config, store, options) {
+    // a JSON round-trip IS the serialization: it thaws the frozen config and
+    // sheds the refs' in-code `process` decorations in one move
+    const manifest = JSON.parse(JSON.stringify(config));
+    await visitResources(ConfigSchema, manifest, store, { signal: options?.signal });
+    return manifest;
+}