@comapeo/map-server 1.0.0-pre.0

package/src/middlewares/parse-request.ts

@@ -0,0 +1,34 @@
+import { type RequestHandler, type IRequestStrict, type IRequest } from 'itty-router'
+import { Type as T, type StaticType } from 'typebox'
+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 = <
+	TSchema extends T.TSchema,
+	TRequest extends IRequest = IRequestStrict,
+>(
+	schema: TSchema,
+): RequestHandler<
+	TRequest & { parsed: StaticType<[], 'Decode', {}, {}, TSchema> }
+> => {
+	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 as StaticType<[], 'Decode', {}, {}, TSchema>
+		} catch (error) {
+			if ('status' in (error as object)) throw error
+			throw new errors.INVALID_REQUEST()
+		}
+	}
+}

package/src/routes/downloads.ts

@@ -0,0 +1,92 @@
+import { IttyRouter } from 'itty-router'
+import { Type as T, type Static } from 'typebox'
+
+import type { Context } from '../context.js'
+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,
+	type RouterExternal,
+} 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 type DownloadCreateParams = Static<typeof DownloadCreateRequest>
+
+export function DownloadsRouter(
+	{ base }: { base: string },
+	ctx: Context,
+): RouterExternal {
+	const downloads = new SelfEvictingTimeoutMap<string, DownloadRequest>()
+	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): Promise<Response> => {
+		const download = getDownload(request.params.downloadId)
+		return createEventStreamResponse(download, { signal: request.signal })
+	})
+
+	router.post('/:downloadId/abort', async (request): Promise<Response> => {
+		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: string): DownloadRequest {
+		const download = downloads.get(downloadId)
+		if (!download) {
+			throw new errors.DOWNLOAD_NOT_FOUND(
+				`Download ID not found: ${downloadId}`,
+			)
+		}
+		return download
+	}
+}

package/src/routes/map-shares.ts

@@ -0,0 +1,246 @@
+import os from 'node:os'
+
+import { IRequestStrict, IttyRouter, type RequestHandler } from 'itty-router'
+import {
+	fetch as secretStreamFetch,
+	Agent as SecretStreamAgent,
+} from 'secret-stream-http'
+import { Type as T, type Static } from 'typebox'
+import { Compile } from 'typebox/compile'
+import z32 from 'z32'
+
+import type { Context } from '../context.js'
+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,
+	MapShareState,
+	type FetchContext,
+	type RouterExternal,
+} from '../types.js'
+
+const MapShareCreateRequest = T.Object({
+	mapId: T.String({ minLength: 1 }),
+	receiverDeviceId: T.String({ minLength: 1 }),
+})
+
+export type MapShareCreateParams = Static<typeof MapShareCreateRequest>
+
+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',
+	}),
+})
+
+export type MapShareDeclineParams = Static<typeof LocalMapShareDeclineRequest>
+
+const RemoteMapShareDeclineRequest = T.Object({
+	reason: MapShareDeclineReason,
+})
+
+const CompiledLocalMapShareDeclineRequest = Compile(LocalMapShareDeclineRequest)
+const CompiledRemoteMapShareDeclineRequest = Compile(
+	RemoteMapShareDeclineRequest,
+)
+
+export function MapSharesRouter(
+	{ base }: { base: string },
+	ctx: Context,
+): RouterExternal {
+	const mapShares = new SelfEvictingTimeoutMap<string, MapShare>()
+
+	const router = IttyRouter<IRequestStrict, [FetchContext]>({ 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): Promise<Response> => {
+			const mapShare = getMapShare(request.params.shareId)
+			return createEventStreamResponse(mapShare, { signal: request.signal })
+		},
+	)
+
+	router.post(
+		'/:shareId/cancel',
+		localhostOnly,
+		async (request): Promise<Response> => {
+			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: IRequestStrict,
+		{ remoteDeviceId, isLocalhost }: FetchContext,
+	) => {
+		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): Promise<MapShareState> => {
+		return getMapShare(request.params.shareId).state
+	})
+
+	router.get('/:shareId/download', async (request): Promise<Response> => {
+		const mapShare = getMapShare(request.params.shareId)
+		const stream = ctx.createMapReadableStream(mapShare.state.mapId)
+		return mapShare.downloadResponse(stream)
+	})
+
+	const localDeclineHandler: RequestHandler = async (request) => {
+		let parsedBody: Static<typeof LocalMapShareDeclineRequest>
+		try {
+			const json = await request.json()
+			if (!CompiledLocalMapShareDeclineRequest.Check(json)) {
+				throw new errors.INVALID_REQUEST()
+			}
+			parsedBody = json
+		} catch (err) {
+			if ('status' in (err as object)) throw err
+			throw new errors.INVALID_REQUEST()
+		}
+		const { senderDeviceId, mapShareUrls, reason } = parsedBody
+		const remotePublicKey = z32.decode(senderDeviceId)
+		const keyPair = ctx.getKeyPair()
+		let response: Response | undefined
+		// 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 }),
+				})) as unknown as Response // 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: RequestHandler = async (request) => {
+		let parsedBody: Static<typeof RemoteMapShareDeclineRequest>
+		try {
+			const json = await request.json()
+			if (!CompiledRemoteMapShareDeclineRequest.Check(json)) {
+				throw new errors.INVALID_REQUEST()
+			}
+			parsedBody = json
+		} catch (err) {
+			if ('status' in (err as object)) 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 }): Promise<Response> => {
+			if (isLocalhost) {
+				return localDeclineHandler(request)
+			} else {
+				return remoteDeclineHandler(request)
+			}
+		},
+	)
+
+	return router
+
+	function getMapShare(shareId: string) {
+		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: string, remotePort: number): string[] {
+	requestUrl = addTrailingSlash(requestUrl)
+	const interfaces = os.networkInterfaces()
+	const baseUrls: string[] = []
+	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/src/routes/maps.ts

@@ -0,0 +1,146 @@
+import { IRequestStrict, IttyRouter, type RequestHandler } from 'itty-router'
+import Mutex from 'p-mutex'
+import { createServer as createSmpServer } from 'styled-map-package/server'
+
+import type { Context } from '../context.js'
+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'
+
+type MapRequest = IRequestStrict & {
+	params: {
+		mapId: string
+	}
+}
+
+export function MapsRouter({ base = '/' }, ctx: Context) {
+	base = addTrailingSlash(base)
+	const uploadMutexes = new Map<string, Mutex>()
+
+	const smpServer = createSmpServer({
+		base: `${base}:mapId/`,
+	})
+
+	const router = IttyRouter<IRequestStrict>({ base })
+
+	router.get<MapRequest>(`/:mapId/info`, async (request) => {
+		const info = await ctx.getMapInfo(request.params.mapId)
+		return {
+			created: info.mapCreated,
+			size: info.estimatedSizeBytes,
+			name: info.mapName,
+		}
+	})
+
+	const uploadHandler: RequestHandler<MapRequest> = 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<MapRequest>('/: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<MapRequest>('/: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: RequestHandler = 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: Response | void
+			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/src/routes/root.ts

@@ -0,0 +1,37 @@
+import { json, Router, type IRequestStrict } from 'itty-router'
+
+import type { Context } from '../context.js'
+import { error } from '../lib/errors.js'
+import { localhostOnly } from '../middlewares/localhost-only.js'
+import type { FetchContext, RouterExternal } from '../types.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: Context): RouterExternal {
+	const router = Router<IRequestStrict, [FetchContext]>({
+		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
+}

package/src/types.ts

@@ -0,0 +1,152 @@
+import type { RequestLike } from 'itty-router'
+import { Type as T, type Static } from 'typebox'
+
+export const MapShareDeclineReason = T.Union([
+	T.Literal('disk_full', {
+		description:
+			"The map share was declined because the receiver's disk is full",
+	}),
+	T.Literal('user_rejected', {
+		description: 'The map share was declined by the user',
+	}),
+	T.String({
+		minLength: 1,
+		description: 'Other reason for declining the map share',
+	}),
+])
+
+const MapShareStateUpdate = T.Union([
+	T.Object({
+		status: T.Literal('pending', {
+			description: 'Map share is awaiting a response',
+		}),
+	}),
+	T.Object({
+		status: T.Literal('declined', {
+			description: 'Map share has been declined',
+		}),
+		reason: MapShareDeclineReason,
+	}),
+	T.Object({
+		status: T.Literal('downloading', {
+			description: 'Map share is currently being downloaded',
+		}),
+		bytesDownloaded: T.Number({
+			description:
+				'Total bytes downloaded so far (compare with estimatedSizeBytes for progress)',
+		}),
+	}),
+	T.Object({
+		status: T.Literal('canceled', {
+			description: 'Map share has been canceled (by the sharer)',
+		}),
+	}),
+	T.Object({
+		status: T.Literal('aborted', {
+			description: 'Map share download was aborted (by the receiver)',
+		}),
+	}),
+	T.Object({
+		status: T.Literal('completed', { description: 'Map has been downloaded' }),
+	}),
+	T.Object({
+		status: T.Literal('error', {
+			description: 'An error occurred while downloading',
+		}),
+		error: T.Object(
+			{
+				message: T.String({ description: 'Error message' }),
+				code: T.String({ description: 'Error code' }),
+			},
+			{
+				description: 'Error that occurred while receiving the map share',
+			},
+		),
+	}),
+])
+
+export type MapShareStateUpdate = Static<typeof MapShareStateUpdate>
+export type MapShareStatus = Static<typeof MapShareStateUpdate>['status']
+
+export type DownloadStateUpdate = Extract<
+	MapShareStateUpdate,
+	{ status: 'downloading' | 'completed' | 'error' | 'canceled' | 'aborted' }
+>
+
+export const MapShareUrls = T.Array(T.String({ format: 'uri' }), {
+	minItems: 1,
+	description:
+		'List of map share URLs (for each network interface of the sharer)',
+})
+export const ShareId = T.String({
+	minLength: 1,
+	description: 'The ID of the map share',
+})
+export type ShareId = Static<typeof ShareId>
+export const EstimatedSizeBytes = T.Number({
+	description: 'Estimated size of the map data in bytes',
+})
+
+const MapInfo = T.Object({
+	mapId: T.String({ description: 'The ID of the map' }),
+	mapName: T.String({ description: 'The name of the map' }),
+	estimatedSizeBytes: EstimatedSizeBytes,
+	bounds: T.ReadonlyType(
+		T.Tuple([T.Number(), T.Number(), T.Number(), T.Number()], {
+			description: 'The bounding box of the map data',
+		}),
+	),
+	minzoom: T.Number({ description: 'The minimum zoom level of the map data' }),
+	maxzoom: T.Number({ description: 'The maximum zoom level of the map data' }),
+	mapCreated: T.Number({
+		description: 'Timestamp (ms since epoch) when the map was created',
+	}),
+})
+
+const MapShareBase = T.Intersect([
+	T.Object({
+		receiverDeviceId: T.String({
+			description: 'The ID of the device that can receive the map share',
+		}),
+		shareId: ShareId,
+		mapShareUrls: MapShareUrls,
+		mapShareCreated: T.Number({
+			description: 'Timestamp (ms since epoch) when the map share was created',
+		}),
+	}),
+	MapInfo,
+])
+
+export const MapShareState = T.Intersect([MapShareBase, MapShareStateUpdate])
+
+export type MapShareState = DistributiveIntersection<
+	Static<typeof MapShareBase>,
+	Static<typeof MapShareStateUpdate>
+>
+
+export type MapInfo = Static<typeof MapInfo>
+
+export type FetchContext = {
+	isLocalhost?: boolean
+	remoteDeviceId?: string
+}
+
+export type DistributiveIntersection<Base, Union> = Union extends unknown
+	? Base & Union
+	: never
+
+export type DistributeProperty<T, K extends keyof T> = T[K] extends infer V
+	? V extends T[K]
+		? { [P in K]: V } & Omit<T, K>
+		: never
+	: never
+
+/**
+ * External router returned by create router functions. Ensures routers are
+ * called with the necessary fetch context
+ */
+export type RouterExternal = {
+	fetch: (request: RequestLike, context: FetchContext) => Promise<any>
+}
+
+export type BBox = Readonly<[number, number, number, number]>