@comapeo/map-server 1.0.0-pre.0

package/dist/lib/utils.js

@@ -0,0 +1,96 @@
+import crypto from 'node:crypto';
+import { randomBytes } from 'crypto';
+import z32 from 'z32';
+/**
+ * If the argument is an `Error` instance, return its `code` property if it is a string.
+ * Otherwise, returns `undefined`.
+ *
+ * @param {unknown} maybeError
+ * @returns {undefined | string}
+ * @example
+ * try {
+ *   // do something
+ * } catch (err) {
+ *   console.error(getErrorCode(err))
+ * }
+ */
+export function getErrorCode(maybeError) {
+    if (maybeError instanceof Error &&
+        'code' in maybeError &&
+        typeof maybeError.code === 'string') {
+        return maybeError.code;
+    }
+    return undefined;
+}
+export function noop() { }
+export function generateId() {
+    return z32.encode(randomBytes(8));
+}
+export function getOrInsert(map, key, value) {
+    if (map.has(key)) {
+        return map.get(key);
+    }
+    map.set(key, value);
+    return value;
+}
+export function timingSafeEqual(a, b) {
+    const aBuf = Buffer.from(a);
+    const bBuf = Buffer.from(b);
+    if (aBuf.length !== bBuf.length) {
+        return false;
+    }
+    return crypto.timingSafeEqual(aBuf, bBuf);
+}
+/**
+ * Returns a bbox that is the smallest bounding box that contains all the input bboxes.
+ *
+ * @param bboxes
+ * @returns Bounding Box [w, s, e, n] of all input bboxes
+ */
+export function unionBBox(bboxes) {
+    let [w, s, e, n] = bboxes[0];
+    for (let i = 1; i < bboxes.length; i++) {
+        const [w1, s1, e1, n1] = bboxes[i];
+        w = Math.min(w, w1);
+        s = Math.min(s, s1);
+        e = Math.max(e, e1);
+        n = Math.max(n, n1);
+    }
+    return [w, s, e, n];
+}
+export function getStyleBbox(style) {
+    const sourceBboxes = [];
+    for (const source of Object.values(style.sources)) {
+        if (!('bounds' in source))
+            continue;
+        sourceBboxes.push(source.bounds);
+    }
+    if (!isNonEmptyArray(sourceBboxes)) {
+        return [-180, -85.0511, 180, 85.0511];
+    }
+    return unionBBox(sourceBboxes);
+}
+export function getStyleMaxZoom(style) {
+    let maxzoom = -1;
+    for (const source of Object.values(style.sources)) {
+        if (!('maxzoom' in source))
+            continue;
+        maxzoom = Math.max(maxzoom, source.maxzoom ?? -1);
+    }
+    return maxzoom === -1 ? 22 : maxzoom;
+}
+export function getStyleMinZoom(style) {
+    let minzoom = 99;
+    for (const source of Object.values(style.sources)) {
+        if (!('minzoom' in source))
+            continue;
+        minzoom = Math.min(minzoom, source.minzoom ?? 99);
+    }
+    return minzoom === 99 ? 0 : minzoom;
+}
+function isNonEmptyArray(arr) {
+    return arr.length > 0;
+}
+export function addTrailingSlash(url) {
+    return url.endsWith('/') ? url : url + '/';
+}

package/dist/middlewares/localhost-only.d.ts

@@ -0,0 +1,11 @@
+import { type IRequestStrict, type RequestHandler } from 'itty-router';
+/**
+ * Middleware to restrict access to localhost only. The localhost listener must
+ * pass { isLocalhost: true } in the context.
+ */
+export declare const localhostOnly: RequestHandler<IRequestStrict, [
+    {
+        isLocalhost: boolean;
+    }
+]>;
+//# sourceMappingURL=localhost-only.d.ts.map

package/dist/middlewares/localhost-only.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"localhost-only.d.ts","sourceRoot":"","sources":["../../src/middlewares/localhost-only.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,cAAc,EAAE,MAAM,aAAa,CAAA;AAItE;;;GAGG;AACH,eAAO,MAAM,aAAa,EAAE,cAAc,CACzC,cAAc,EACd;IAAC;QAAE,WAAW,EAAE,OAAO,CAAA;KAAE;CAAC,CAK1B,CAAA"}

package/dist/middlewares/localhost-only.js

@@ -0,0 +1,10 @@
+import { errors } from '../lib/errors.js';
+/**
+ * Middleware to restrict access to localhost only. The localhost listener must
+ * pass { isLocalhost: true } in the context.
+ */
+export const localhostOnly = async (_, { isLocalhost }) => {
+    if (!isLocalhost) {
+        throw new errors.FORBIDDEN();
+    }
+};

package/dist/middlewares/parse-request.d.ts

@@ -0,0 +1,11 @@
+import { type RequestHandler, type IRequestStrict, type IRequest } from 'itty-router';
+import { Type as T, type StaticType } from 'typebox';
+/**
+ * A small helper to create middleware that parses and validates the request
+ * body against the given schema. Downstream handlers can access the type-safe
+ * parsed body via `request.parsed`.
+ */
+export declare const parseRequest: <TSchema extends T.TSchema, TRequest extends IRequest = IRequestStrict>(schema: TSchema) => RequestHandler<TRequest & {
+    parsed: StaticType<[], "Decode", {}, {}, TSchema>;
+}>;
+//# sourceMappingURL=parse-request.d.ts.map

package/dist/middlewares/parse-request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-request.d.ts","sourceRoot":"","sources":["../../src/middlewares/parse-request.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,cAAc,EAAE,KAAK,QAAQ,EAAE,MAAM,aAAa,CAAA;AACrF,OAAO,EAAE,IAAI,IAAI,CAAC,EAAE,KAAK,UAAU,EAAE,MAAM,SAAS,CAAA;AAKpD;;;;GAIG;AACH,eAAO,MAAM,YAAY,GACxB,OAAO,SAAS,CAAC,CAAC,OAAO,EACzB,QAAQ,SAAS,QAAQ,GAAG,cAAc,EAE1C,QAAQ,OAAO,KACb,cAAc,CAChB,QAAQ,GAAG;IAAE,MAAM,EAAE,UAAU,CAAC,EAAE,EAAE,QAAQ,EAAE,EAAE,EAAE,EAAE,EAAE,OAAO,CAAC,CAAA;CAAE,CAgBhE,CAAA"}

package/dist/middlewares/parse-request.js

@@ -0,0 +1,25 @@
+import { Compile } from 'typebox/compile';
+import { errors } from '../lib/errors.js';
+/**
+ * A small helper to create middleware that parses and validates the request
+ * body against the given schema. Downstream handlers can access the type-safe
+ * parsed body via `request.parsed`.
+ */
+export const parseRequest = (schema) => {
+    const C = Compile(schema);
+    return async (request) => {
+        try {
+            const json = await request.json();
+            // Use Check to validate without type coercion
+            if (!C.Check(json)) {
+                throw new errors.INVALID_REQUEST();
+            }
+            request.parsed = json;
+        }
+        catch (error) {
+            if ('status' in error)
+                throw error;
+            throw new errors.INVALID_REQUEST();
+        }
+    };
+};

package/dist/routes/downloads.d.ts

@@ -0,0 +1,15 @@
+import { Type as T, type Static } from 'typebox';
+import type { Context } from '../context.js';
+import { type RouterExternal } from '../types.js';
+declare const DownloadCreateRequest: T.TObject<{
+    senderDeviceId: T.TString;
+    mapShareUrls: T.TArray<T.TString>;
+    shareId: T.TString;
+    estimatedSizeBytes: T.TNumber;
+}>;
+export type DownloadCreateParams = Static<typeof DownloadCreateRequest>;
+export declare function DownloadsRouter({ base }: {
+    base: string;
+}, ctx: Context): RouterExternal;
+export {};
+//# sourceMappingURL=downloads.d.ts.map

package/dist/routes/downloads.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"downloads.d.ts","sourceRoot":"","sources":["../../src/routes/downloads.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,IAAI,IAAI,CAAC,EAAE,KAAK,MAAM,EAAE,MAAM,SAAS,CAAA;AAEhD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AAQ5C,OAAO,EAIN,KAAK,cAAc,EACnB,MAAM,aAAa,CAAA;AAEpB,QAAA,MAAM,qBAAqB;;;;;EAQzB,CAAA;AAEF,MAAM,MAAM,oBAAoB,GAAG,MAAM,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEvE,wBAAgB,eAAe,CAC9B,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,EAC1B,GAAG,EAAE,OAAO,GACV,cAAc,CA0DhB"}

package/dist/routes/downloads.js

@@ -0,0 +1,60 @@
+import { IttyRouter } from 'itty-router';
+import { Type as T } from 'typebox';
+import { CUSTOM_MAP_ID } from '../lib/constants.js';
+import { DownloadRequest } from '../lib/download-request.js';
+import { errors } from '../lib/errors.js';
+import { createEventStreamResponse } from '../lib/event-stream-response.js';
+import { SelfEvictingTimeoutMap } from '../lib/self-evicting-map.js';
+import { addTrailingSlash } from '../lib/utils.js';
+import { parseRequest } from '../middlewares/parse-request.js';
+import { MapShareUrls, EstimatedSizeBytes, ShareId, } from '../types.js';
+const DownloadCreateRequest = T.Object({
+    senderDeviceId: T.String({
+        minLength: 1,
+        description: 'The ID of the device that is sending the map share',
+    }),
+    mapShareUrls: MapShareUrls,
+    shareId: ShareId,
+    estimatedSizeBytes: EstimatedSizeBytes,
+});
+export function DownloadsRouter({ base }, ctx) {
+    const downloads = new SelfEvictingTimeoutMap();
+    const router = IttyRouter({ base });
+    router.post('/', parseRequest(DownloadCreateRequest), async (request) => {
+        const writable = ctx.createMapWritableStream(CUSTOM_MAP_ID);
+        const download = new DownloadRequest(writable, request.parsed, ctx.getKeyPair());
+        downloads.set(download.state.downloadId, download);
+        return Response.json(download.state, {
+            status: 201,
+            headers: {
+                Location: new URL(download.state.downloadId, addTrailingSlash(request.url)).href,
+            },
+        });
+    });
+    router.get('/', () => {
+        return Array.from(downloads.values()).map((d) => d.state);
+    });
+    router.get('/:downloadId', async (request) => {
+        return getDownload(request.params.downloadId).state;
+    });
+    router.get('/:downloadId/events', async (request) => {
+        const download = getDownload(request.params.downloadId);
+        return createEventStreamResponse(download, { signal: request.signal });
+    });
+    router.post('/:downloadId/abort', async (request) => {
+        const download = getDownload(request.params.downloadId);
+        if (download.state.status !== 'downloading') {
+            throw new errors.ABORT_NOT_DOWNLOADING(`Cannot abort: download status is '${download.state.status}'`);
+        }
+        download.cancel();
+        return new Response(null, { status: 204 });
+    });
+    return router;
+    function getDownload(downloadId) {
+        const download = downloads.get(downloadId);
+        if (!download) {
+            throw new errors.DOWNLOAD_NOT_FOUND(`Download ID not found: ${downloadId}`);
+        }
+        return download;
+    }
+}

package/dist/routes/map-shares.d.ts

@@ -0,0 +1,19 @@
+import { Type as T, type Static } from 'typebox';
+import type { Context } from '../context.js';
+import { type RouterExternal } from '../types.js';
+declare const MapShareCreateRequest: T.TObject<{
+    mapId: T.TString;
+    receiverDeviceId: T.TString;
+}>;
+export type MapShareCreateParams = Static<typeof MapShareCreateRequest>;
+declare const LocalMapShareDeclineRequest: T.TObject<{
+    reason: T.TUnion<[T.TLiteral<"disk_full">, T.TLiteral<"user_rejected">, T.TString]>;
+    mapShareUrls: T.TArray<T.TString>;
+    senderDeviceId: T.TString;
+}>;
+export type MapShareDeclineParams = Static<typeof LocalMapShareDeclineRequest>;
+export declare function MapSharesRouter({ base }: {
+    base: string;
+}, ctx: Context): RouterExternal;
+export {};
+//# sourceMappingURL=map-shares.d.ts.map

package/dist/routes/map-shares.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"map-shares.d.ts","sourceRoot":"","sources":["../../src/routes/map-shares.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,IAAI,IAAI,CAAC,EAAE,KAAK,MAAM,EAAE,MAAM,SAAS,CAAA;AAIhD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AAQ5C,OAAO,EAKN,KAAK,cAAc,EACnB,MAAM,aAAa,CAAA;AAEpB,QAAA,MAAM,qBAAqB;;;EAGzB,CAAA;AAEF,MAAM,MAAM,oBAAoB,GAAG,MAAM,CAAC,OAAO,qBAAqB,CAAC,CAAA;AAEvE,QAAA,MAAM,2BAA2B;;;;EAO/B,CAAA;AAEF,MAAM,MAAM,qBAAqB,GAAG,MAAM,CAAC,OAAO,2BAA2B,CAAC,CAAA;AAW9E,wBAAgB,eAAe,CAC9B,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,EAC1B,GAAG,EAAE,OAAO,GACV,cAAc,CAuKhB"}

package/dist/routes/map-shares.js

@@ -0,0 +1,192 @@
+import os from 'node:os';
+import { IttyRouter } from 'itty-router';
+import { fetch as secretStreamFetch, Agent as SecretStreamAgent, } from 'secret-stream-http';
+import { Type as T } from 'typebox';
+import { Compile } from 'typebox/compile';
+import z32 from 'z32';
+import { errors, StatusError } from '../lib/errors.js';
+import { createEventStreamResponse } from '../lib/event-stream-response.js';
+import { MapShare } from '../lib/map-share.js';
+import { SelfEvictingTimeoutMap } from '../lib/self-evicting-map.js';
+import { addTrailingSlash, timingSafeEqual } from '../lib/utils.js';
+import { localhostOnly } from '../middlewares/localhost-only.js';
+import { parseRequest } from '../middlewares/parse-request.js';
+import { MapShareUrls, MapShareDeclineReason, } from '../types.js';
+const MapShareCreateRequest = T.Object({
+    mapId: T.String({ minLength: 1 }),
+    receiverDeviceId: T.String({ minLength: 1 }),
+});
+const LocalMapShareDeclineRequest = T.Object({
+    reason: MapShareDeclineReason,
+    mapShareUrls: MapShareUrls,
+    senderDeviceId: T.String({
+        minLength: 1,
+        description: 'The ID of the device that is sending the map share',
+    }),
+});
+const RemoteMapShareDeclineRequest = T.Object({
+    reason: MapShareDeclineReason,
+});
+const CompiledLocalMapShareDeclineRequest = Compile(LocalMapShareDeclineRequest);
+const CompiledRemoteMapShareDeclineRequest = Compile(RemoteMapShareDeclineRequest);
+export function MapSharesRouter({ base }, ctx) {
+    const mapShares = new SelfEvictingTimeoutMap();
+    const router = IttyRouter({ base });
+    // These routes are only accessible from localhost (local API)
+    router.post('/', localhostOnly, parseRequest(MapShareCreateRequest), async (request) => {
+        const { mapId, receiverDeviceId } = request.parsed;
+        const mapInfo = await ctx.getMapInfo(mapId);
+        const mapShare = new MapShare({
+            ...mapInfo,
+            receiverDeviceId,
+            baseUrls: getRemoteBaseUrls(request.url, await ctx.getRemotePort()),
+        });
+        mapShares.set(mapShare.shareId, mapShare);
+        return Response.json(mapShare.state, {
+            status: 201,
+            headers: {
+                Location: new URL(mapShare.shareId, addTrailingSlash(request.url))
+                    .href,
+            },
+        });
+    });
+    router.get('/', localhostOnly, () => {
+        return Array.from(mapShares.values()).map((ms) => ms.state);
+    });
+    router.get('/:shareId/events', localhostOnly, async (request) => {
+        const mapShare = getMapShare(request.params.shareId);
+        return createEventStreamResponse(mapShare, { signal: request.signal });
+    });
+    router.post('/:shareId/cancel', localhostOnly, async (request) => {
+        const mapShare = getMapShare(request.params.shareId);
+        mapShare.cancel();
+        return new Response(null, { status: 204 });
+    });
+    // These routes can be accessed by a remote peer, but the peer deviceId must
+    // match the receiverDeviceId on the map share
+    const validateRemoteDeviceId = async (request, { remoteDeviceId, isLocalhost }) => {
+        if (isLocalhost)
+            return;
+        if (!remoteDeviceId) {
+            throw new errors.FORBIDDEN();
+        }
+        const mapShare = getMapShare(request.params.shareId);
+        if (!timingSafeEqual(remoteDeviceId, mapShare.state.receiverDeviceId)) {
+            throw new errors.FORBIDDEN();
+        }
+    };
+    router.all('/:shareId', validateRemoteDeviceId);
+    router.all('/:shareId/*', validateRemoteDeviceId);
+    router.get('/:shareId', async (request) => {
+        return getMapShare(request.params.shareId).state;
+    });
+    router.get('/:shareId/download', async (request) => {
+        const mapShare = getMapShare(request.params.shareId);
+        const stream = ctx.createMapReadableStream(mapShare.state.mapId);
+        return mapShare.downloadResponse(stream);
+    });
+    const localDeclineHandler = async (request) => {
+        let parsedBody;
+        try {
+            const json = await request.json();
+            if (!CompiledLocalMapShareDeclineRequest.Check(json)) {
+                throw new errors.INVALID_REQUEST();
+            }
+            parsedBody = json;
+        }
+        catch (err) {
+            if ('status' in err)
+                throw err;
+            throw new errors.INVALID_REQUEST();
+        }
+        const { senderDeviceId, mapShareUrls, reason } = parsedBody;
+        const remotePublicKey = z32.decode(senderDeviceId);
+        const keyPair = ctx.getKeyPair();
+        let response;
+        // The sharer could have multiple IPs for different network interfaces, and
+        // not all of them may be on the same network as us, so try each URL until
+        // one works
+        for (const mapShareUrl of mapShareUrls) {
+            const url = new URL('decline', addTrailingSlash(mapShareUrl));
+            try {
+                response = (await secretStreamFetch(url, {
+                    method: 'POST',
+                    body: JSON.stringify({ reason }),
+                    signal: request.signal,
+                    dispatcher: new SecretStreamAgent({ remotePublicKey, keyPair }),
+                })); // Subtle difference bewteen Undici fetch Response and whatwg Response
+                break; // Exit loop on successful fetch
+            }
+            catch (error) {
+                if (error instanceof DOMException && error.name === 'AbortError') {
+                    throw error; // Handle abort in caller
+                }
+                // Otherwise, try the next URL
+            }
+        }
+        if (!response) {
+            throw new errors.DECLINE_CANNOT_CONNECT();
+        }
+        if (!response.ok) {
+            // pass through error from sender
+            throw new StatusError(response.status, await response.json());
+        }
+        return new Response(null, { status: 204 });
+    };
+    const remoteDeclineHandler = async (request) => {
+        let parsedBody;
+        try {
+            const json = await request.json();
+            if (!CompiledRemoteMapShareDeclineRequest.Check(json)) {
+                throw new errors.INVALID_REQUEST();
+            }
+            parsedBody = json;
+        }
+        catch (err) {
+            if ('status' in err)
+                throw err;
+            throw new errors.INVALID_REQUEST();
+        }
+        const { reason } = parsedBody;
+        const mapShare = getMapShare(request.params.shareId);
+        mapShare.decline(reason);
+        return new Response(null, { status: 204 });
+    };
+    router.post('/:shareId/decline', async (request, { isLocalhost }) => {
+        if (isLocalhost) {
+            return localDeclineHandler(request);
+        }
+        else {
+            return remoteDeclineHandler(request);
+        }
+    });
+    return router;
+    function getMapShare(shareId) {
+        const mapShare = mapShares.get(shareId);
+        if (!mapShare) {
+            throw new errors.MAP_SHARE_NOT_FOUND(`Map share ID not found: ${shareId}`);
+        }
+        return mapShare;
+    }
+}
+/**
+ * Get the base URLs for downloads for all non-internal IPv4 addresses of the machine
+ */
+function getRemoteBaseUrls(requestUrl, remotePort) {
+    requestUrl = addTrailingSlash(requestUrl);
+    const interfaces = os.networkInterfaces();
+    const baseUrls = [];
+    for (const iface of Object.values(interfaces)) {
+        if (!iface)
+            continue;
+        for (const addr of iface) {
+            if (addr.family === 'IPv4' && !addr.internal) {
+                const url = new URL(requestUrl);
+                url.hostname = addr.address;
+                url.port = remotePort.toString();
+                baseUrls.push(url.toString());
+            }
+        }
+    }
+    return baseUrls;
+}

package/dist/routes/maps.d.ts

@@ -0,0 +1,6 @@
+import { IRequestStrict } from 'itty-router';
+import type { Context } from '../context.js';
+export declare function MapsRouter({ base }: {
+    base?: string | undefined;
+}, ctx: Context): import("itty-router").IttyRouterType<IRequestStrict, any[], any>;
+//# sourceMappingURL=maps.d.ts.map

package/dist/routes/maps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"maps.d.ts","sourceRoot":"","sources":["../../src/routes/maps.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAmC,MAAM,aAAa,CAAA;AAI7E,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AAe5C,wBAAgB,UAAU,CAAC,EAAE,IAAU,EAAE;;CAAA,EAAE,GAAG,EAAE,OAAO,oEA8HtD"}

package/dist/routes/maps.js

@@ -0,0 +1,118 @@
+import { IttyRouter } from 'itty-router';
+import Mutex from 'p-mutex';
+import { createServer as createSmpServer } from 'styled-map-package/server';
+import { CUSTOM_MAP_ID, DEFAULT_MAP_ID, FALLBACK_MAP_ID, } from '../lib/constants.js';
+import { errors } from '../lib/errors.js';
+import { addTrailingSlash, noop } from '../lib/utils.js';
+export function MapsRouter({ base = '/' }, ctx) {
+    base = addTrailingSlash(base);
+    const uploadMutexes = new Map();
+    const smpServer = createSmpServer({
+        base: `${base}:mapId/`,
+    });
+    const router = IttyRouter({ base });
+    router.get(`/:mapId/info`, async (request) => {
+        const info = await ctx.getMapInfo(request.params.mapId);
+        return {
+            created: info.mapCreated,
+            size: info.estimatedSizeBytes,
+            name: info.mapName,
+        };
+    });
+    const uploadHandler = async (request) => {
+        const writable = ctx.createMapWritableStream(request.params.mapId);
+        if (!request.body) {
+            throw new errors.INVALID_REQUEST('Request body is required');
+        }
+        await request.body.pipeTo(writable);
+    };
+    router.put('/:mapId', async (request) => {
+        // Only allow uploading to the custom map ID for now
+        if (request.params.mapId === DEFAULT_MAP_ID ||
+            request.params.mapId === FALLBACK_MAP_ID) {
+            throw new errors.FORBIDDEN(`Uploading to map ID "${request.params.mapId}" is not allowed`);
+        }
+        else if (request.params.mapId !== CUSTOM_MAP_ID) {
+            throw new errors.MAP_NOT_FOUND(`Map not found: ${request.params.mapId}`);
+        }
+        if (!request.body) {
+            throw new errors.INVALID_REQUEST('Request body is required');
+        }
+        // Get or create a mutex for this mapId to ensure sequential uploads
+        let mutex = uploadMutexes.get(request.params.mapId);
+        if (!mutex) {
+            mutex = new Mutex();
+            uploadMutexes.set(request.params.mapId, mutex);
+        }
+        await mutex.withLock(() => uploadHandler(request));
+        return new Response(null, { status: 200 });
+    });
+    router.delete('/:mapId', async (request) => {
+        // Only allow deleting the custom map ID
+        if (request.params.mapId === DEFAULT_MAP_ID ||
+            request.params.mapId === FALLBACK_MAP_ID) {
+            throw new errors.FORBIDDEN(`Deleting the map ID "${request.params.mapId}" is not allowed`);
+        }
+        else if (request.params.mapId !== CUSTOM_MAP_ID) {
+            throw new errors.MAP_NOT_FOUND(`Map not found: ${request.params.mapId}`);
+        }
+        // Use mutex to wait for any active uploads to complete before deleting
+        let mutex = uploadMutexes.get(request.params.mapId);
+        if (!mutex) {
+            mutex = new Mutex();
+            uploadMutexes.set(request.params.mapId, mutex);
+        }
+        await mutex.withLock(() => ctx.deleteMap(request.params.mapId));
+        return new Response(null, { status: 204 });
+    });
+    router.all(`/:mapId/*`, async (request) => {
+        if (request.params.mapId === DEFAULT_MAP_ID) {
+            return defaultMapHandler(request);
+        }
+        // Get the reader first - this throws MAP_NOT_FOUND for unknown map IDs
+        const reader = await ctx.getReader(request.params.mapId);
+        try {
+            return await smpServer.fetch(request, reader);
+        }
+        catch (err) {
+            // Convert generic 404 from smpServer to RESOURCE_NOT_FOUND
+            if (err instanceof Error && 'status' in err && err.status === 404) {
+                throw new errors.RESOURCE_NOT_FOUND();
+            }
+            throw err;
+        }
+    });
+    // Special handler for the default map ID that tries to serve a custom map
+    // if available, otherwise falls back to the online style or bundled fallback
+    const defaultMapHandler = async (request) => {
+        const defaultOnlineStyleUrl = ctx.getDefaultOnlineStyleUrl();
+        const styleUrls = [
+            new URL(`../${CUSTOM_MAP_ID}/style.json`, request.url),
+            defaultOnlineStyleUrl,
+            new URL(`../${FALLBACK_MAP_ID}/style.json`, request.url),
+        ];
+        for (const url of styleUrls) {
+            let response;
+            if (url === defaultOnlineStyleUrl) {
+                response = await fetch(url).catch(noop);
+            }
+            else {
+                // No need to go through the networking stack for local requests
+                response = await router.fetch(new Request(url)).catch(noop);
+            }
+            response?.body?.cancel(); // Close the connection
+            if (response && response.ok) {
+                return new Response(null, {
+                    status: 302,
+                    headers: {
+                        location: url.toString(),
+                        'access-control-allow-origin': '*',
+                        'cache-control': 'no-cache',
+                    },
+                });
+            }
+        }
+        throw new errors.MAP_NOT_FOUND('No available map style found');
+    };
+    return router;
+}

package/dist/routes/root.d.ts

@@ -0,0 +1,6 @@
+import type { Context } from '../context.js';
+import type { RouterExternal } from '../types.js';
+export declare function RootRouter({ base }: {
+    base?: string | undefined;
+}, ctx: Context): RouterExternal;
+//# sourceMappingURL=root.d.ts.map

package/dist/routes/root.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"root.d.ts","sourceRoot":"","sources":["../../src/routes/root.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAA;AAG5C,OAAO,KAAK,EAAgB,cAAc,EAAE,MAAM,aAAa,CAAA;AAS/D,wBAAgB,UAAU,CAAC,EAAE,IAAU,EAAE;;CAAA,EAAE,GAAG,EAAE,OAAO,GAAG,cAAc,CAsBvE"}

package/dist/routes/root.js

@@ -0,0 +1,29 @@
+import { json, Router } from 'itty-router';
+import { error } from '../lib/errors.js';
+import { localhostOnly } from '../middlewares/localhost-only.js';
+import { DownloadsRouter } from './downloads.js';
+import { MapSharesRouter } from './map-shares.js';
+import { MapsRouter } from './maps.js';
+const MAPS_BASE = '/maps/';
+const MAP_SHARES_BASE = '/mapShares/';
+const DOWNLOADS_BASE = '/downloads/';
+export function RootRouter({ base = '/' }, ctx) {
+    const router = Router({
+        base,
+        // The `error` handler will send a response with the status code from any
+        // thrown StatusError, or a 500 for any other errors.
+        catch: (err) => error(err),
+        // Sends a 404 response for any requests that don't match a route, and for
+        // any request handlers that return JSON will send a JSON response.
+        finally: [(response) => response ?? error(404), json],
+    });
+    const mapsRouter = MapsRouter({ base: MAPS_BASE }, ctx);
+    const downloadsRouter = DownloadsRouter({ base: DOWNLOADS_BASE }, ctx);
+    const mapSharesRouter = MapSharesRouter({ base: MAP_SHARES_BASE }, ctx);
+    router.all(`${MAPS_BASE}*`, localhostOnly, mapsRouter.fetch);
+    router.all(`${DOWNLOADS_BASE}*`, localhostOnly, downloadsRouter.fetch);
+    // Some map share routes are remote-accessible - localhostOnly is applied in
+    // the map shares router where needed
+    router.all(`${MAP_SHARES_BASE}*`, mapSharesRouter.fetch);
+    return router;
+}