@expofp/offline 3.11.12 → 3.12.1

package/README.md

@@ -1,57 +1,22 @@
-## Offline: generating ZIPs
+# @expofp/offline
 
-The `@expofp/offline` package provides a CLI (`expofp-offline`) that creates self-contained ZIP archives of floor plans. The ZIP can be opened in any browser without internet connectivity.
+CLI (`expofp-offline`) that creates self-contained ZIP archives of floor plans — openable in any browser without internet connectivity.
 
-### Usage
+## Usage
 
 ```bash
 npx @expofp/offline@<tag-or-version> <manifest-url> [options]
 ```
 
-Use a dist-tag or exact version to match the deployed floor plan (e.g. `@latest`, `@stable`, `@customer1`, `@3.0.0-alpha.9`).
+| Option                   | Description                                      | Default                                |
+| ------------------------ | ------------------------------------------------ | -------------------------------------- |
+| `-o`, `--output`         | Output file path                                 | `offline.zip`                          |
+| `--debug-no-offline-map` | Disable automatic MapLibre basemap detection.    |                                        |
+| `--debug-map-source`     | Global PMTiles source URL/path for offline maps. | Latest available Protomaps daily build |
+| `-h`, `--help`           | Show help message                                |                                        |
 
-| Option             | Description                                                              | Default                                |
-| ------------------ | ------------------------------------------------------------------------ | -------------------------------------- |
-| `-o`, `--output`   | Output file path                                                         | `offline.zip`                          |
-| `--map-debug`      | Enable debug-only map flags. Do not use in production.                   |                                        |
-| `--no-offline-map` | Disable automatic MapLibre basemap detection. Requires `--map-debug`.    |                                        |
-| `--map-source`     | Global PMTiles source URL/path for offline maps. Requires `--map-debug`. | Latest available Protomaps daily build |
-| `-h`, `--help`     | Show help message                                                        |                                        |
-| `-v`, `--version`  | Show version number                                                      |                                        |
-
-### Example
-
-```bash
-npx @expofp/offline@stable https://demo.expofp.com/manifest.json -o offline.zip
-```
-
-Offline MapLibre basemaps are inferred automatically from `__fpGeo.properties.config`:
-
-```bash
-npx @expofp/offline@next https://demo.expofp.com/manifest.json -o offline.zip
-```
-
-To skip automatic offline map generation for debugging only:
-
-```bash
-npx @expofp/offline@next https://demo.expofp.com/manifest.json \
-  --map-debug \
-  --no-offline-map \
-  -o offline.zip
-```
-
-If `--map-source` is omitted, the CLI checks `https://build.protomaps.com/YYYYMMDD.pmtiles`
-starting from the current date and falls back to previous dates for up to 7 days.
-For debugging only, pass `--map-debug --map-source` explicitly to use a specific PMTiles URL or local file.
-
-Offline map extraction requires the `pmtiles` CLI binary to be available in `PATH`.
-This is separate from the `pmtiles` npm package used by the browser runtime.
-On macOS, install the CLI with `brew install pmtiles`.
-
-### Debugging
-
-Enable debug output with the `DEBUG` env variable:
+## Example
 
 ```bash
-DEBUG=efp:offline:* npx @expofp/offline https://...
+npx @expofp/offline https://demo.expofp.com/manifest.json -o offline.zip
 ```

package/dist/cli.js

@@ -13,13 +13,11 @@ Arguments:
 
 Options:
   -o, --output   Output file path (default: offline.zip)
-      --map-debug
-                Enable debug-only map flags. Do not use in production.
-      --no-offline-map
-                Disable automatic offline MapLibre basemap detection (requires --map-debug)
-      --map-source <source>
+      --debug-no-offline-map
+                Disable automatic offline MapLibre basemap detection
+      --debug-map-source <source>
                 Global PMTiles source URL/path used for the offline map
-                Defaults to the latest available Protomaps daily build (requires --map-debug)
+                Defaults to the latest available Protomaps daily build
   -h, --help     Show this help message
   -v, --version  Show version number
 `.trim();
@@ -30,16 +28,13 @@ async function main() {
         abortController.abort(new Error('Aborted by SIGINT'));
     };
     process.once('SIGINT', abortOnSigint);
-    const rawArgs = process.argv.slice(2);
-    const noOfflineMap = rawArgs.includes('--no-offline-map');
     const { values, positionals } = parseArgs({
-        args: rawArgs.filter((arg) => arg !== '--no-offline-map'),
+        args: process.argv.slice(2),
         allowPositionals: true,
-        allowNegative: true,
         options: {
             output: { type: 'string', short: 'o', default: 'offline.zip' },
-            'map-debug': { type: 'boolean', default: false },
-            'map-source': { type: 'string' },
+            'debug-no-offline-map': { type: 'boolean', default: false },
+            'debug-map-source': { type: 'string' },
             help: { type: 'boolean', short: 'h', default: false },
             version: { type: 'boolean', short: 'v', default: false },
         },
@@ -73,20 +68,14 @@ async function main() {
         console.error('Error: output path must end with .zip\n');
         process.exit(1);
     }
-    if (!values['map-debug'] && noOfflineMap) {
-        console.error('Error: --no-offline-map requires --map-debug and is for debug only\n');
+    if (values['debug-no-offline-map'] && values['debug-map-source']) {
+        console.error('Error: --debug-map-source cannot be used with --debug-no-offline-map\n');
         process.exit(1);
     }
-    if (!values['map-debug'] && values['map-source']) {
-        console.error('Error: --map-source requires --map-debug and is for debug only\n');
-        process.exit(1);
-    }
-    if (noOfflineMap && values['map-source']) {
-        console.error('Error: --map-source cannot be used with --no-offline-map\n');
-        process.exit(1);
-    }
-    const offlineMap = values['map-source'] ? { mapSource: values['map-source'] } : undefined;
-    const inferOfflineMap = !noOfflineMap;
+    const offlineMap = values['debug-map-source']
+        ? { mapSource: values['debug-map-source'] }
+        : undefined;
+    const inferOfflineMap = !values['debug-no-offline-map'];
     console.log(`Resolving @expofp/floorplan runtime...`);
     const runtimeBaseUrl = await resolveFloorplanDir();
     console.log(`Creating offline ZIP from ${manifestUrl}...`);

package/dist/lib/data-to-files.d.ts

@@ -1,4 +1,5 @@
 import { type LocalData } from './types.js';
+export declare const FILE_FETCH_TIMEOUT_MS = 60000;
 export declare function dataToFiles(data: AsyncIterable<LocalData>, options?: {
     signal?: AbortSignal;
 }): AsyncIterable<{

package/dist/lib/data-to-files.js

@@ -2,14 +2,19 @@ import { readFileFromUrl } from '@expofp/utils';
 import debug from 'debug';
 import { withTimeout } from './abort-signal.js';
 const log = debug('efp:offline:data-to-files');
-const FILE_FETCH_TIMEOUT_MS = 60_000;
+export const FILE_FETCH_TIMEOUT_MS = 60_000;
 export async function* dataToFiles(data, options) {
     for await (const file of data) {
         if ('url' in file) {
             const signal = withTimeout(options?.signal, FILE_FETCH_TIMEOUT_MS);
             const response = await readFileFromUrl(file.url, { signal });
             if (!response.ok) {
-                console.warn(`Skipping file ${file.url} as it could not be downloaded`);
+                // only expected-missing resources (fabricated variant URLs) may be
+                // skipped — an archive silently missing anything else is broken
+                if (!file.optional) {
+                    throw new Error(`Failed to download ${file.url}`);
+                }
+                console.warn(`Skipping optional file ${file.url} as it could not be downloaded`);
             }
             else {
                 log('Bundling file from url', file.targetFilePath);

package/dist/lib/download-offline-zip.d.ts

@@ -1,4 +1,5 @@
-import { type Manifest, type Ref } from '@expofp/data';
+import { type Manifest } from '@expofp/config';
+import { type Ref } from '@expofp/resolve';
 import { type OfflineOptions } from './types.js';
 export declare function downloadOfflineZip(manifest: Manifest | Ref<Manifest>, options: OfflineOptions): Promise<void>;
 //# sourceMappingURL=download-offline-zip.d.ts.map

package/dist/lib/generate-offline-data.d.ts

@@ -1,5 +1,13 @@
-import { type Manifest, type Ref } from '@expofp/data';
+import { type Manifest } from '@expofp/config';
+import { type Ref } from '@expofp/resolve';
 import { type LocalData, type OfflineOptions } from './types.js';
+/**
+ * An offline copy is nothing but a serialized config: `loadConfig` produces
+ * the complete event data document (refs warm, every asset URL absolute), and
+ * `serializeConfigResources` walks it — this package only decides WHERE
+ * things go (page-relative archive-local paths, so the copy resolves against
+ * wherever `index.html` is mounted) and zips the result with the runtime.
+ */
 export declare function generateOfflineData(inputManifest: Manifest | Ref<Manifest>, options: OfflineOptions): AsyncIterable<LocalData, void>;
 /** Build a complete offline ZIP archive from a manifest. */
 export declare function buildOfflineZip(manifest: Manifest | Ref<Manifest>, options: OfflineOptions): Promise<Blob>;

package/dist/lib/generate-offline-data.js

@@ -1,38 +1,42 @@
-import { resolve } from '@expofp/resolve';
-import { buildZipArchive, deepClone } from '@expofp/utils';
+import { loadConfig, serializeConfigResources, } from '@expofp/config';
+import { getResolved, resolve } from '@expofp/resolve';
+import { buildZipArchive, deepClone, makeLocalPath, readFileFromUrl } from '@expofp/utils';
 import debug from 'debug';
-import { dataToFiles } from './data-to-files.js';
-import { generateOfflineDataLegacy } from './generate-offline-data-legacy.js';
+import { withTimeout } from './abort-signal.js';
+import { dataToFiles, FILE_FETCH_TIMEOUT_MS } from './data-to-files.js';
 import { generateOfflineMapData, inferOfflineMapOptions, validateOfflineMapOptions, } from './generate-offline-map-data.js';
 import { generateRuntimeFilesData } from './generate-runtime-files-data.js';
-import { offlinizeAssetsInPlace } from './offlinize-assets-in-place.js';
 const log = debug('efp:offline:generate-offline-data');
+/**
+ * An offline copy is nothing but a serialized config: `loadConfig` produces
+ * the complete event data document (refs warm, every asset URL absolute), and
+ * `serializeConfigResources` walks it — this package only decides WHERE
+ * things go (page-relative archive-local paths, so the copy resolves against
+ * wherever `index.html` is mounted) and zips the result with the runtime.
+ */
 export async function* generateOfflineData(inputManifest, options) {
     const manifest = deepClone(await resolve(inputManifest, { signal: options.signal }));
     log(`Generating offline files for expo: ${manifest.expo}`);
-    const pathPrefix = manifest.expo;
+    const config = await loadConfig(manifest, {});
+    const pathPrefix = config.expo;
     // this is a requirement of mobile SDK, paths in the ZIP must be prefixed with the expo name
     // TODO: make sure SDK works with unprefixed paths, and remove the prefixing logic from this function
     const prefixPath = (path) => `${pathPrefix}/${path}`;
-    const legacyDataUrlBase = manifest.legacyDataUrlBase;
-    let maplibre;
-    const offlineMap = await resolveOfflineMapOptions(manifest, options);
-    if (manifest.legacyDataUrlBase) {
-        for await (const d of generateOfflineDataLegacy(manifest, options)) {
-            yield { ...d, targetFilePath: prefixPath(d.targetFilePath) };
-        }
+    const offlineMap = await resolveOfflineMapOptions(config, options);
+    const { files, localManifest } = await serializeConfig(config, options.signal);
+    for (const d of files) {
+        yield { ...d, targetFilePath: prefixPath(d.targetFilePath) };
     }
     if (offlineMap) {
-        const mapData = generateOfflineMapData({ ...manifest, legacyDataUrlBase }, { ...offlineMap, signal: options.signal });
+        const mapData = generateOfflineMapData({
+            ...offlineMap,
+            fpSvgContext: getFpSvgJs(config),
+            signal: options.signal,
+        });
         for await (const d of mapData.files) {
             yield { ...d, targetFilePath: prefixPath(d.targetFilePath) };
         }
-        maplibre = mapData.maplibre;
-    }
-    // transform entire manifest + assets
-    const data = await offlinizeAssetsInPlace(manifest, options);
-    for (const d of data) {
-        yield { ...d, targetFilePath: prefixPath(d.targetFilePath) };
+        localManifest.maplibre = { ...mapData.maplibre };
     }
     // add runtime files — manually iterate to prefix paths while capturing return value
     const runtimeGen = generateRuntimeFilesData(options.runtimeBaseUrl);
@@ -45,15 +49,89 @@ export async function* generateOfflineData(inputManifest, options) {
         runtimeResult = await runtimeGen.next();
     }
     const { entry } = runtimeResult.value;
+    // the archive's manifest — the whole event data document, everything resolved
+    yield {
+        text: JSON.stringify(localManifest, null, 2),
+        targetFilePath: prefixPath('manifest.json'),
+    };
     // generate index.html
     yield {
-        text: getIndexHtml(entry, manifest, maplibre),
+        text: getIndexHtml(entry, 'manifest.json'),
         targetFilePath: prefixPath('index.html'),
     };
 }
-async function resolveOfflineMapOptions(manifest, options) {
+/**
+ * The storage policy behind `serializeConfigResources`: assets land at their
+ * `makeLocalPath`, referenced documents are saved as `.json` files, and
+ * everything is addressed with **page-relative** URLs — bare `makeLocalPath`
+ * output, no leading slash — so the archive resolves wherever `index.html` is
+ * mounted (inside the expo folder, a parent at `/<expo>/`, or the SDK mount)
+ * alike. Non-remote (already-local or `data:`) resources pass through as-is.
+ */
+async function serializeConfig(config, signal) {
+    const files = [];
+    const seenPaths = new Set();
+    const add = (entry) => {
+        if (!seenPaths.has(entry.targetFilePath)) {
+            seenPaths.add(entry.targetFilePath);
+            files.push(entry);
+        }
+    };
+    const isRemote = (url) => /^https?:\/\//i.test(url);
+    const store = {
+        async asset(url, optional) {
+            if (!isRemote(url))
+                return url;
+            const targetFilePath = await makeLocalPath(new URL(url));
+            add({ url: new URL(url), targetFilePath, optional });
+            return targetFilePath;
+        },
+        async document(refUrl, document) {
+            const targetFilePath = documentPath(await makeLocalPath(new URL(refUrl)));
+            add({ text: JSON.stringify(document), targetFilePath });
+            return targetFilePath;
+        },
+        // @import'ed stylesheets (e.g. Google Fonts css2) are spliced into the
+        // importing CSS rather than saved as files — an extension-less saved
+        // stylesheet would be served with the wrong MIME type, and splicing lets
+        // the ordinary asset pass localize the fonts the import pulls in.
+        async stylesheetText(url) {
+            const response = await readFileFromUrl(new URL(url), {
+                signal: withTimeout(signal, FILE_FETCH_TIMEOUT_MS),
+            });
+            if (!response.ok)
+                throw new Error(`Failed to download @import'ed stylesheet ${url}`);
+            return new TextDecoder().decode(response.data);
+        },
+        documentError(refUrl, error) {
+            // The wayfinding graph is optional — an expo without one is normal, so
+            // (like the fabricated __small/__tiny logo variants) warn and drop the
+            // ref. Any other document missing means a broken archive: fail the build.
+            if (refUrl === config.wfDataJsRef?.$ref) {
+                console.warn(`Skipping wayfinding graph ${refUrl} as it could not be resolved`, error);
+                return;
+            }
+            throw error;
+        },
+    };
+    const localManifest = await serializeConfigResources(config, store, { signal });
+    return { files, localManifest };
+}
+/** Saved documents are resolved JSON, whatever the live file was called. */
+function documentPath(localPath) {
+    if (localPath.endsWith('.json'))
+        return localPath;
+    return localPath.replace(/\.js$/i, '') + '.json';
+}
+/** The eagerly-resolved drawing payload (loadConfig warmed the ref). */
+function getFpSvgJs(config) {
+    if (!config.fpSvgJsRef)
+        throw new Error('config has no drawing (fpSvgJsRef)');
+    return getResolved(config.fpSvgJsRef);
+}
+async function resolveOfflineMapOptions(config, options) {
     if (options.inferOfflineMap) {
-        return await inferOfflineMapOptions(manifest, options.offlineMap, options.signal);
+        return await inferOfflineMapOptions(getFpSvgJs(config), options.offlineMap, options.signal);
     }
     if (options.offlineMap) {
         return await validateOfflineMapOptions(options.offlineMap, options.signal);
@@ -68,7 +146,7 @@ export async function buildOfflineZip(manifest, options) {
 }
 /** Known path — file lives in `packages/floorplan/public/` and is copied to dist by Vite. */
 const COMPAT_HELPER = 'compat-helper.js';
-function getIndexHtml(entry, manifest, maplibre) {
+function getIndexHtml(entry, manifestRef) {
     // entry is "./runtime/index.js", derive the runtime base path
     const runtimeBase = entry.slice(0, entry.lastIndexOf('/') + 1);
     return `\
@@ -76,22 +154,7 @@ function getIndexHtml(entry, manifest, maplibre) {
 <script src="${runtimeBase}${COMPAT_HELPER}"></script>
 <script type="module">
   import { load } from ${JSON.stringify(entry)};
-  const options = ${JSON.stringify({ ...manifest, maplibre })};
-  if (options.maplibre && options.maplibre.offline && options.maplibre.styleUrl) {
-    const styleUrl = new URL(options.maplibre.styleUrl, window.location.href);
-    const style = await fetch(styleUrl).then((response) => response.json());
-    const resolveStyleUrl = (url) => new URL(url, styleUrl).href.replaceAll('%7B', '{').replaceAll('%7D', '}');
-    if (typeof style.sprite === 'string') style.sprite = resolveStyleUrl(style.sprite);
-    if (typeof style.glyphs === 'string') style.glyphs = resolveStyleUrl(style.glyphs);
-    for (const source of Object.values(style.sources || {})) {
-      if (source && typeof source.url === 'string' && source.url.startsWith('pmtiles://')) {
-        source.url = 'pmtiles://' + new URL(source.url.slice('pmtiles://'.length), styleUrl).href;
-      }
-    }
-    options.maplibre.style = style;
-    delete options.maplibre.styleUrl;
-  }
-  await load(options);
+  await load({ $ref: ${JSON.stringify(manifestRef)} });
 </script>
 `;
 }

package/dist/lib/generate-offline-map-data.d.ts

@@ -1,5 +1,4 @@
-import { type Manifest } from '@expofp/data';
-import type { MaplibreOptions } from '@expofp/floorplan';
+import type { MaplibreOptions } from '@expofp/schema';
 import { type LocalData, type OfflineMapOptions } from './types.js';
 type FpSvgContext = Record<string, unknown>;
 export type ValidatedOfflineMapOptions = OfflineMapOptions & {
@@ -10,10 +9,12 @@ export interface OfflineMapResult {
     files: AsyncIterable<LocalData>;
     maplibre: MaplibreOptions;
 }
-export declare function generateOfflineMapData(manifest: Manifest, options: ValidatedOfflineMapOptions & {
+export declare function generateOfflineMapData(options: ValidatedOfflineMapOptions & {
+    fpSvgContext: FpSvgContext;
     signal?: AbortSignal;
 }): OfflineMapResult;
 export declare function validateOfflineMapOptions(options: OfflineMapOptions, signal?: AbortSignal): Promise<ValidatedOfflineMapOptions>;
-export declare function inferOfflineMapOptions(manifest: Manifest, options: OfflineMapOptions | undefined, signal?: AbortSignal): Promise<ValidatedOfflineMapOptions | undefined>;
+/** An offline map applies only when the (already-loaded) drawing is geo-referenced. */
+export declare function inferOfflineMapOptions(fpSvgContext: FpSvgContext, options: OfflineMapOptions | undefined, signal?: AbortSignal): Promise<ValidatedOfflineMapOptions | undefined>;
 export {};
 //# sourceMappingURL=generate-offline-map-data.d.ts.map

package/dist/lib/generate-offline-map-data.js

@@ -1,7 +1,5 @@
 import { Box, projectLocalToGps } from '@expofp/geometry';
-import { resolve } from '@expofp/resolve';
 import debug from 'debug';
-import { execScriptInSandbox } from './exec-script-in-sandbox.js';
 const log = debug('efp:offline:generate-offline-map-data');
 const MAPS_BASE_PATH = 'maps/';
 const MAP_STYLE_PATH = `${MAPS_BASE_PATH}style.json`;
@@ -34,16 +32,13 @@ const ENGLISH_LABEL_FIELD = [
     ['get', 'name'],
 ];
 const tempDirExitCleanups = new Map();
-export function generateOfflineMapData(manifest, options) {
+export function generateOfflineMapData(options) {
     const maplibre = {
         styleUrl: `./${MAP_STYLE_PATH}`,
         offline: true,
     };
     async function* files() {
-        if (!manifest.legacyDataUrlBase) {
-            throw new Error('Offline map generation requires legacyDataUrlBase in the manifest.');
-        }
-        const bbox = await derivePaddedVenueBbox(manifest, options.fpSvgContext, options.signal);
+        const bbox = derivePaddedVenueBbox(options.fpSvgContext);
         log('Extracting PMTiles for bbox', bbox.join(','));
         const pmtilesFile = await extractPmtiles(options.mapSource, bbox, options.signal);
         try {
@@ -75,10 +70,8 @@ export async function validateOfflineMapOptions(options, signal) {
     await assertPmtilesCliAvailable(signal);
     return { ...options, mapSource };
 }
-export async function inferOfflineMapOptions(manifest, options, signal) {
-    if (!manifest.legacyDataUrlBase)
-        return undefined;
-    const fpSvgContext = await resolveFpSvgContext(manifest, signal);
+/** An offline map applies only when the (already-loaded) drawing is geo-referenced. */
+export async function inferOfflineMapOptions(fpSvgContext, options, signal) {
     const fpGeo = fpSvgContext.__fpGeo;
     if (!fpGeo?.properties?.config)
         return undefined;
@@ -97,7 +90,7 @@ async function resolveDefaultMapSource(signal) {
             throw new Error(`Unable to check default offline map source ${source}: HTTP ${response.status}`);
         }
     }
-    throw new Error(`Could not find a default Protomaps PMTiles build from the last ${DEFAULT_MAP_SOURCE_LOOKBACK_DAYS} days. Specify --map-source explicitly.`);
+    throw new Error(`Could not find a default Protomaps PMTiles build from the last ${DEFAULT_MAP_SOURCE_LOOKBACK_DAYS} days. Specify --debug-map-source explicitly.`);
 }
 function createDefaultMapSource(dayOffset) {
     const date = new Date();
@@ -107,8 +100,7 @@ function createDefaultMapSource(dayOffset) {
     const day = String(date.getUTCDate()).padStart(2, '0');
     return `${DEFAULT_MAP_SOURCE_BASE}/${year}${month}${day}.pmtiles`;
 }
-async function derivePaddedVenueBbox(manifest, fpSvgContext, signal) {
-    const ctx = fpSvgContext ?? (await resolveFpSvgContext(manifest, signal));
+function derivePaddedVenueBbox(ctx) {
     const fpGeo = ctx.__fpGeo;
     const config = fpGeo?.properties?.config;
     if (!config) {
@@ -157,15 +149,6 @@ async function derivePaddedVenueBbox(manifest, fpSvgContext, signal) {
     const latPadding = padH / M_PER_DEG_LAT;
     return [minLng - lngPadding, minLat - latPadding, maxLng + lngPadding, maxLat + latPadding];
 }
-async function resolveFpSvgContext(manifest, signal) {
-    if (!manifest.legacyDataUrlBase) {
-        throw new Error('Offline map generation requires legacyDataUrlBase in the manifest.');
-    }
-    const version = await resolve(manifest.legacyDataVersion, { signal })
-        .then((json) => json?.version)
-        .catch(() => Date.now().toString());
-    return await execScriptInSandbox(`${manifest.legacyDataUrlBase}fp.svg.js?v=${version}`, signal);
-}
 // The offline map extent — the whole SVG canvas, NOT the fit box: the full
 // viewBox unioned with the explicit authored area (`__viewbox` / `rect#VIEWBOX`).
 // Basing this on the
@@ -238,7 +221,7 @@ async function assertPmtilesCliAvailable(signal) {
 async function assertValidMapSource(mapSource) {
     const source = mapSource.trim();
     if (!source || source !== mapSource || source.startsWith('-')) {
-        throw new Error('Offline map --map-source must be an http(s)/file URL or absolute path.');
+        throw new Error('Offline map --debug-map-source must be an http(s)/file URL or absolute path.');
     }
     const path = await import('node:path');
     if (path.isAbsolute(source) || path.win32.isAbsolute(source))
@@ -251,7 +234,7 @@ async function assertValidMapSource(mapSource) {
     catch {
         // Fall through to the consistent validation error below.
     }
-    throw new Error('Offline map --map-source must be an http(s)/file URL or absolute path.');
+    throw new Error('Offline map --debug-map-source must be an http(s)/file URL or absolute path.');
 }
 async function extractPmtiles(mapSource, bbox, signal) {
     const { mkdtemp } = await import('node:fs/promises');

package/dist/lib/save-offline-zip.d.ts

@@ -1,4 +1,5 @@
-import { type Manifest, type Ref } from '@expofp/data';
+import { type Manifest } from '@expofp/config';
+import { type Ref } from '@expofp/resolve';
 import { type OfflineOptions } from './types.js';
 export declare function saveOfflineZip(manifest: Manifest | Ref<Manifest>, path: string, options: OfflineOptions): Promise<void>;
 //# sourceMappingURL=save-offline-zip.d.ts.map

package/dist/lib/types.d.ts

@@ -2,6 +2,8 @@ export type LocalData = LocalDataFetch | LocalDataText;
 export interface LocalDataFetch {
     url: URL;
     targetFilePath: string;
+    /** An expected-missing resource (fabricated variant URLs): skip, don't fail, when the download fails. */
+    optional?: boolean;
 }
 export interface LocalDataText {
     text: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@expofp/offline",
-  "version": "3.11.12",
+  "version": "3.12.1",
   "type": "module",
   "description": "CLI tool for creating offline copies of ExpoFP floor plans",
   "homepage": "https://developer.expofp.com/",
@@ -31,10 +31,11 @@
   "dependencies": {
     "debug": "^4.4.3",
     "tslib": "^2.3.0",
-    "@expofp/data": "3.11.12",
-    "@expofp/floorplan": "3.11.12",
-    "@expofp/resolve": "3.11.12",
-    "@expofp/geometry": "3.11.12",
-    "@expofp/utils": "3.11.12"
+    "@expofp/config": "3.12.1",
+    "@expofp/geometry": "3.12.1",
+    "@expofp/floorplan": "3.12.1",
+    "@expofp/resolve": "3.12.1",
+    "@expofp/schema": "3.12.1",
+    "@expofp/utils": "3.12.1"
   }
 }

package/dist/lib/exec-script-in-sandbox.d.ts

@@ -1,3 +0,0 @@
-/** Fetch a legacy data script and execute it in a compatibility vm context. */
-export declare function execScriptInSandbox(url: string, signal?: AbortSignal): Promise<Record<string, unknown>>;
-//# sourceMappingURL=exec-script-in-sandbox.d.ts.map

package/dist/lib/exec-script-in-sandbox.js

@@ -1,44 +0,0 @@
-import { fetchWithRetry } from '@expofp/utils';
-import { withTimeout } from './abort-signal.js';
-const SCRIPT_FETCH_TIMEOUT_MS = 60_000;
-const SCRIPT_EXECUTION_TIMEOUT_MS = 5_000;
-const LEGACY_SCRIPT_ALLOWED_ORIGINS_ENV = 'EXPOFP_OFFLINE_LEGACY_SCRIPT_ORIGINS';
-/** Fetch a legacy data script and execute it in a compatibility vm context. */
-export async function execScriptInSandbox(url, signal) {
-    assertTrustedLegacyScriptUrl(url);
-    const fetchSignal = withTimeout(signal, SCRIPT_FETCH_TIMEOUT_MS);
-    const response = await fetchWithRetry(url, { signal: fetchSignal });
-    if (!response.ok) {
-        throw new Error(`Failed to fetch script (HTTP ${response.status}): ${url}`);
-    }
-    const code = await response.text();
-    const { runInNewContext } = await import('node:vm');
-    const sandbox = {};
-    sandbox.window = sandbox; // legacy scripts expect window === globalThis
-    // The vm context is not a security boundary; origin validation above is required.
-    runInNewContext(code, sandbox, { timeout: SCRIPT_EXECUTION_TIMEOUT_MS });
-    return sandbox;
-}
-function assertTrustedLegacyScriptUrl(url) {
-    const parsed = new URL(url);
-    if (parsed.protocol !== 'https:' && parsed.protocol !== 'http:') {
-        throw new Error(`Legacy script URL must use http or https: ${url}`);
-    }
-    const allowedOrigins = getAllowedLegacyScriptOrigins();
-    if (isDefaultAllowedHost(parsed.hostname) || allowedOrigins.includes(parsed.origin))
-        return;
-    throw new Error(`Legacy script host is not allowed: ${parsed.hostname}. Add ${parsed.origin} to ${LEGACY_SCRIPT_ALLOWED_ORIGINS_ENV} to allow it.`);
-}
-function getAllowedLegacyScriptOrigins() {
-    return (process.env[LEGACY_SCRIPT_ALLOWED_ORIGINS_ENV] ?? '')
-        .split(',')
-        .map((origin) => origin.trim())
-        .filter(Boolean);
-}
-function isDefaultAllowedHost(hostname) {
-    return (hostname === 'expofp.com' ||
-        hostname.endsWith('.expofp.com') ||
-        hostname === 'localhost' ||
-        hostname === '127.0.0.1' ||
-        hostname === '::1');
-}

package/dist/lib/generate-offline-data-legacy.d.ts

@@ -1,6 +0,0 @@
-import { type Manifest } from '@expofp/data';
-import { type LocalData } from './types.js';
-export declare function generateOfflineDataLegacy(manifest: Manifest, options: {
-    signal?: AbortSignal;
-}): AsyncIterable<LocalData>;
-//# sourceMappingURL=generate-offline-data-legacy.d.ts.map

package/dist/lib/generate-offline-data-legacy.js

@@ -1,86 +0,0 @@
-import { resolve } from '@expofp/resolve';
-import { deepClone, makeLocalPath } from '@expofp/utils';
-import debug from 'debug';
-import { execScriptInSandbox } from './exec-script-in-sandbox.js';
-import { offlinizeAssetsInPlace } from './offlinize-assets-in-place.js';
-const log = debug('efp:offline:generate-offline-data-legacy');
-export async function* generateOfflineDataLegacy(manifest, options) {
-    if (!manifest.legacyDataUrlBase) {
-        throw new Error('Manifest does not have legacyDataUrlBase');
-    }
-    const { signal } = options;
-    const legacyDataUrlBase = manifest.legacyDataUrlBase;
-    const version = await resolve(manifest.legacyDataVersion, { signal })
-        .then((json) => json?.version)
-        .catch(() => {
-        log('Could not resolve legacyDataVersion, proceeding without it');
-        return Date.now().toString();
-    });
-    const localDataUrlBase = await makeLocalPath(new URL(legacyDataUrlBase));
-    // data.js — execute in isolated vm context to extract __data
-    const dataCtx = await execScriptInSandbox(`${legacyDataUrlBase}data.js?v=${version}`, signal);
-    const data = deepClone(dataCtx.__data);
-    yield* offlinizeDataJs(data, legacyDataUrlBase, signal);
-    // Asset paths in data are absolute (e.g. "https-demo-expofp-com/data/exhibitors/...").
-    // The runtime resolves them relative to legacyDataUrlBase, so strip that prefix
-    // to avoid doubling (e.g. "base/base/exhibitors/...").
-    stripPathPrefix(data, localDataUrlBase);
-    yield {
-        text: `__data = ${JSON.stringify(data, null, 2)};`,
-        targetFilePath: `${localDataUrlBase}data.js`,
-    };
-    // wf.data.js
-    const wfDataUrl = `${legacyDataUrlBase}wf.data.js?v=${version}`;
-    yield { url: new URL(wfDataUrl), targetFilePath: `${localDataUrlBase}wf.data.js` };
-    // fp.svg.js — execute in isolated vm context to extract __fpLayers
-    const svgCtx = await execScriptInSandbox(`${legacyDataUrlBase}fp.svg.js?v=${version}`, signal);
-    yield {
-        url: new URL(`${legacyDataUrlBase}fp.svg.js?v=${version}`),
-        targetFilePath: `${localDataUrlBase}fp.svg.js`,
-    };
-    // fp.svg.{layer}.js
-    const fpLayers = svgCtx.__fpLayers || [];
-    for (const layer of fpLayers) {
-        const layerFile = `fp.svg.${layer.name}.js`;
-        const layerUrl = `${legacyDataUrlBase}${layerFile}?v=${version}`;
-        yield { url: new URL(layerUrl), targetFilePath: `${localDataUrlBase}${layerFile}` };
-    }
-    manifest.legacyDataUrlBase = localDataUrlBase;
-}
-/** Strip a path prefix from all string values in a data tree (in place). */
-function stripPathPrefix(node, prefix) {
-    if (Array.isArray(node)) {
-        for (let i = 0; i < node.length; i++) {
-            const el = node[i];
-            if (typeof el === 'string' && el.startsWith(prefix)) {
-                node[i] = el.slice(prefix.length);
-            }
-            else if (el && typeof el === 'object') {
-                stripPathPrefix(el, prefix);
-            }
-        }
-        return;
-    }
-    if (!node || typeof node !== 'object') {
-        return;
-    }
-    const obj = node;
-    for (const key of Object.keys(obj)) {
-        const val = obj[key];
-        if (typeof val === 'string' && val.startsWith(prefix)) {
-            obj[key] = val.slice(prefix.length);
-        }
-        else if (val && typeof val === 'object') {
-            stripPathPrefix(val, prefix);
-        }
-    }
-}
-async function* offlinizeDataJs(data, legacyDataUrlBase, signal) {
-    if (data.customCss) {
-        console.warn('data.customCss is deprecated, renaming to data.customCssAssetText');
-        data.customCssAssetText = data.customCss;
-        delete data.customCss;
-    }
-    const fetches = await offlinizeAssetsInPlace(data, { legacyDataUrlBase, signal });
-    yield* fetches;
-}

package/dist/lib/offlinize-asset-url.d.ts

@@ -1,6 +0,0 @@
-import { type LocalDataFetch } from './types.js';
-export declare function offlinizeAssetUrl(url: URL, variants?: string[]): Promise<{
-    url: string;
-    assets: LocalDataFetch[];
-}>;
-//# sourceMappingURL=offlinize-asset-url.d.ts.map

package/dist/lib/offlinize-asset-url.js

@@ -1,35 +0,0 @@
-import { makeLocalPath } from '@expofp/utils';
-import debug from 'debug';
-const log = debug('efp:offline:offlinize-asset-url');
-export async function offlinizeAssetUrl(url, variants = []) {
-    // main
-    const targetFilePath = await makeLocalPath(url);
-    const assets = [];
-    log(`Offlinized asset: ${url.href} -> ${targetFilePath}`);
-    assets.push({ url, targetFilePath });
-    // extra variants (don’t mutate JSON; just add extra fetches)
-    for (const variant of variants) {
-        const variantUrl = withVariant(url, variant);
-        const variantTargetFilePath = await makeLocalPath(url, variant);
-        assets.push({ url: variantUrl, targetFilePath: variantTargetFilePath });
-        log(`Offlinized variant: ${variantUrl.href} -> ${variantTargetFilePath}`);
-    }
-    return {
-        url: targetFilePath,
-        assets,
-    };
-    function withVariant(url, variant) {
-        const u = new URL(url); // clone
-        const pathname = u.pathname;
-        const lastSlash = pathname.lastIndexOf('/');
-        const filename = lastSlash >= 0 ? pathname.slice(lastSlash + 1) : pathname;
-        const dot = filename.lastIndexOf('.');
-        const nextFilename = dot > 0
-            ? `${filename.slice(0, dot)}${variant}${filename.slice(dot)}`
-            : `${filename}${variant}`;
-        u.pathname =
-            lastSlash >= 0 ? `${pathname.slice(0, lastSlash + 1)}${nextFilename}` : nextFilename;
-        // IMPORTANT: do not touch u.search
-        return u;
-    }
-}

package/dist/lib/offlinize-assets-in-place.d.ts

@@ -1,6 +0,0 @@
-import { type LocalData } from './types.js';
-export declare function offlinizeAssetsInPlace(data: unknown, opts: {
-    legacyDataUrlBase?: string;
-    signal?: AbortSignal;
-}): Promise<LocalData[]>;
-//# sourceMappingURL=offlinize-assets-in-place.d.ts.map

package/dist/lib/offlinize-assets-in-place.js

@@ -1,137 +0,0 @@
-import { fetchWithRetry, makeLocalPath } from '@expofp/utils';
-import debug from 'debug';
-import { offlinizeAssetUrl } from './offlinize-asset-url.js';
-import { offlinizeCssAssetText } from './offlinize-css-asset-text.js';
-const log = debug('efp:offline:offlinize-assets-in-place');
-const ASSET_URL_SUFFIX = 'AssetUrl';
-const CSS_ASSET_TEXT_SUFFIX = 'CssAssetText';
-// Legacy fields, remove in future versions
-const LEGACY_ASSET_URL_FIELDS = ['logo', 'gallery', 'leadingImageUrl', 'photoFile', 'logoFile'];
-const LEGACY_EXHIBITOR_LOGO_VARIANTS = ['__small', '__tiny'];
-const LEGACY_CSS_ASSET_TEXT_FIELD = 'customCss';
-export async function offlinizeAssetsInPlace(data, opts) {
-    const { legacyDataUrlBase } = opts;
-    const fetches = [];
-    const fetchedUrls = new Map(); // targetPath to LocalData
-    const mergeFetches = (newFetches) => {
-        // push only new fetches
-        // error if duplicate targetFilePath with different content
-        for (const nf of newFetches) {
-            const existing = fetchedUrls.get(nf.targetFilePath);
-            // test only if both have url (i.e., are not JSON)
-            if (existing && 'url' in nf && 'url' in existing) {
-                const isSame = existing.url.href === nf.url.href;
-                if (!isSame) {
-                    throw new Error(`Conflicting fetch for targetFilePath ${nf.targetFilePath}: ${existing.url.href} vs ${nf.url.href}`);
-                }
-            }
-            else {
-                fetchedUrls.set(nf.targetFilePath, nf);
-                fetches.push(nf);
-            }
-        }
-    };
-    const processedRefs = new Map(); // Cache for $ref documents
-    const isPlainObject = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
-    const toAbsoluteUrl = (value) => legacyDataUrlBase ? new URL(value, legacyDataUrlBase) : new URL(value);
-    const enableLegacy = !!legacyDataUrlBase;
-    async function walk(node) {
-        if (Array.isArray(node)) {
-            for (const el of node) {
-                if (el && typeof el === 'object') {
-                    await walk(el);
-                }
-            }
-            return;
-        }
-        if (!isPlainObject(node))
-            return;
-        // Handle $ref field
-        if ('$ref' in node && typeof node.$ref === 'string') {
-            const refValue = node.$ref;
-            if (refValue) {
-                const url = toAbsoluteUrl(refValue);
-                const fragment = url.hash; // Preserve JSON pointer fragment
-                // Create URL without fragment for fetching
-                const urlWithoutFragment = new URL(url.href);
-                urlWithoutFragment.hash = '';
-                const urlKey = urlWithoutFragment.href;
-                const targetFilePath = await makeLocalPath(urlWithoutFragment);
-                // Update $ref to local path with preserved fragment
-                node.$ref = targetFilePath + fragment;
-                // Check if we've already processed this $ref URL
-                if (!processedRefs.has(urlKey)) {
-                    // Mark as fetched to prevent duplicates
-                    log(`Offlinizing $ref: ${refValue} -> ${targetFilePath}${fragment}`);
-                    // Fetch and recursively process the referenced document
-                    const response = await fetchWithRetry(urlKey, { signal: opts.signal });
-                    if (response.ok) {
-                        const referencedData = (await response.json());
-                        processedRefs.set(urlKey, referencedData);
-                        log(`Processing referenced document: ${urlKey}`);
-                        // Recursively offlinize assets in the referenced document
-                        const refFetches = await offlinizeAssetsInPlace(referencedData, opts);
-                        fetches.push(...refFetches);
-                        // Store the transformed referenced data as a separate JSON file
-                        fetches.push({
-                            targetFilePath,
-                            text: JSON.stringify(referencedData, null, 2),
-                        });
-                    }
-                    else {
-                        throw new Error(`Failed to fetch $ref URL: ${urlKey}, status: ${response.status}`);
-                    }
-                }
-                else {
-                    log(`Skipping already processed $ref: ${refValue}`);
-                }
-            }
-        }
-        for (const key of Object.keys(node)) {
-            const value = node[key];
-            // CSS asset text handling
-            if (typeof value === 'string' &&
-                (key.endsWith(CSS_ASSET_TEXT_SUFFIX) || key === LEGACY_CSS_ASSET_TEXT_FIELD)) {
-                const { css, assets } = await offlinizeCssAssetText(value);
-                node[key] = css;
-                mergeFetches(assets);
-                continue;
-            }
-            // URL asset handling
-            if (typeof value === 'string' && key.endsWith(ASSET_URL_SUFFIX)) {
-                const { url: localUrl, assets } = await offlinizeAssetUrl(toAbsoluteUrl(value));
-                node[key] = localUrl;
-                mergeFetches(assets);
-                continue;
-            }
-            // Legacy asset URL fields handling
-            if (enableLegacy && LEGACY_ASSET_URL_FIELDS.includes(key) && typeof value === 'string') {
-                let variants = [];
-                if (key === 'logo' || (value.includes('exhibitor/') && value.includes('/media/'))) {
-                    variants = LEGACY_EXHIBITOR_LOGO_VARIANTS;
-                }
-                const { url: localUrl, assets } = await offlinizeAssetUrl(toAbsoluteUrl(value), variants);
-                node[key] = localUrl;
-                mergeFetches(assets);
-                continue;
-            }
-            // Legacy asset URL fields handling for arrays
-            if (enableLegacy && LEGACY_ASSET_URL_FIELDS.includes(key) && Array.isArray(value)) {
-                for (let i = 0; i < value.length; i++) {
-                    const el = value[i];
-                    if (typeof el === 'string') {
-                        const { url: localUrl, assets } = await offlinizeAssetUrl(toAbsoluteUrl(el));
-                        value[i] = localUrl;
-                        mergeFetches(assets);
-                    }
-                }
-                continue;
-            }
-            if (value && typeof value === 'object') {
-                await walk(value);
-            }
-        }
-    }
-    await walk(data);
-    return fetches;
-}

package/dist/lib/offlinize-css-asset-text.d.ts

@@ -1,6 +0,0 @@
-import { type LocalDataFetch } from './types.js';
-export declare function offlinizeCssAssetText(css: string): Promise<{
-    css: string;
-    assets: LocalDataFetch[];
-}>;
-//# sourceMappingURL=offlinize-css-asset-text.d.ts.map

package/dist/lib/offlinize-css-asset-text.js

@@ -1,52 +0,0 @@
-import { makeLocalPath } from '@expofp/utils';
-import debug from 'debug';
-const log = debug('efp:offline:offlinize-css-asset-text');
-export async function offlinizeCssAssetText(css) {
-    const assets = [];
-    const urlRegex = /url\(\s*(['"]?)(.*?)\1\s*\)/g;
-    // Collect all URL matches first
-    const matches = [];
-    let regexMatch;
-    while ((regexMatch = urlRegex.exec(css)) !== null) {
-        matches.push({
-            match: regexMatch[0],
-            quote: regexMatch[1],
-            urlString: regexMatch[2],
-            index: regexMatch.index,
-        });
-    }
-    // Process all URLs and await their local paths
-    const replacements = await Promise.all(matches.map(async ({ match, quote, urlString }) => {
-        // Do not process data: URLs
-        if (urlString.startsWith('data:')) {
-            return { original: match, replacement: match };
-        }
-        // Only process if it's a valid URL
-        try {
-            const url = new URL(urlString);
-            const localPath = await makeLocalPath(url);
-            assets.push({
-                url,
-                targetFilePath: localPath,
-            });
-            log(`Offlinized CSS asset: ${urlString} -> ${localPath}`);
-            return {
-                original: match,
-                replacement: `url(${quote}${localPath}${quote})`,
-            };
-        }
-        catch {
-            console.warn(`Invalid URL in CSS: ${urlString}`);
-            return { original: match, replacement: match };
-        }
-    }));
-    // Apply all replacements
-    let processedCss = css;
-    for (const { original, replacement } of replacements) {
-        processedCss = processedCss.replace(original, replacement);
-    }
-    return {
-        css: processedCss,
-        assets,
-    };
-}