@octanejs/react-map-gl 0.0.1

package/LICENSE

@@ -0,0 +1,62 @@
+@octanejs/react-map-gl is a port of @vis.gl/react-mapbox (react-map-gl).
+Adapted algorithms, types and reused modules retain the upstream notice below.
+
+Copyright Vis.gl contributors.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+
+This contains code from  MapboxGL-js
+
+Copyright (c) 2014, Mapbox
+
+All rights reserved.
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright notice,
+      this list of conditions and the following disclaimer in the documentation
+      and/or other materials provided with the distribution.
+    * Neither the name of Mapbox GL JS nor the names of its contributors
+      may be used to endorse or promote products derived from this software
+      without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+-------------------------------------------------------------------------------
+
+Contains code from Mapbox GL Style JSON
+
+Mapbox Open Styles are copyright (c) 2014, Mapbox, all rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+- Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.md

@@ -0,0 +1,112 @@
+# @octanejs/react-map-gl
+
+Mapbox GL JS bindings for Octane — a port of
+[`@vis.gl/react-mapbox@8.1.2`](https://github.com/visgl/react-map-gl), the
+package `react-map-gl/mapbox` re-exports.
+
+```bash
+pnpm add @octanejs/react-map-gl mapbox-gl
+```
+
+`mapbox-gl` is an optional peer dependency (`>= 3.5.0`) and is never bundled.
+From v2 it ships under the Mapbox Terms of Service and bills per map load, so
+you bring your own copy and your own access token.
+
+```tsx
+import { Layer, Map, Marker, NavigationControl, Source } from '@octanejs/react-map-gl';
+import 'mapbox-gl/dist/mapbox-gl.css';
+
+export function CityMap() @{
+	<Map
+		mapboxAccessToken={import.meta.env.VITE_MAPBOX_TOKEN}
+		initialViewState={{ longitude: -122.4, latitude: 37.8, zoom: 11 }}
+		mapStyle="mapbox://styles/mapbox/streets-v12"
+		style={{ width: '100%', height: 480 }}
+	>
+		<NavigationControl />
+		<Marker longitude={-122.4} latitude={37.8}>
+			<span class="pin">📍</span>
+		</Marker>
+		<Source id="places" type="geojson" data={places}>
+			<Layer id="places-circles" type="circle" paint={{ 'circle-radius': 6 }} />
+		</Source>
+	</Map>
+}
+```
+
+## Compatibility
+
+Complete against the pinned upstream public surface: `Map` (also the default
+export), `Marker`, `Popup`, `Source`, `Layer`, `AttributionControl`,
+`FullscreenControl`, `GeolocateControl`, `NavigationControl`, `ScaleControl`,
+`useControl`, `MapProvider`, `useMap`, and every published type.
+
+Both `@octanejs/react-map-gl` and `@octanejs/react-map-gl/mapbox` resolve to the
+same surface, so either import style works.
+
+Upstream's framework-neutral half — the Mapbox engine, the proxy transform, the
+map ref and six utility modules — is reused **byte-for-byte**, and upstream's own
+specs for it run here against both upstream's source and this package's copies.
+
+## Intentional differences
+
+**Refs are plain props.** Octane has no `forwardRef`, so `Map`, `Marker`, `Popup`
+and `GeolocateControl` declare `ref` as an ordinary prop. `<Map ref={mapRef} />`
+is unchanged; only your own `forwardRef` wrappers need removing.
+
+**`<Source>` publishes its id through context.** Upstream clones each child with
+`{source: id}`. Octane cannot clone a compiled children block, so the id travels
+by context instead. The enclosing source still wins over a `source` set on the
+layer, exactly as `cloneElement` made it win — but the id now reaches *any*
+descendant `<Layer>`, not just direct children. Give a layer an explicit source
+and keep it outside the `<Source>` if it must not belong to it.
+
+**`<Marker>` picks its element from what your children rendered.** Upstream asks
+`React.Children.forEach` whether it was handed a truthy child, and gives the
+marker its own element to portal into if so. A compiled children block is opaque,
+and evaluating it to look inside would re-run any hooks it contains against the
+same call-site slots, so this binding infers the answer from what the block
+rendered and rebuilds the marker once it knows. Children that render something,
+render nothing, or first render after mount all behave as they do upstream. The
+one difference: a child that stays truthy while never rendering anything gets
+Mapbox's default pin here, where upstream leaves an empty, invisible element.
+
+**Teardown is not synchronous with unmount.** Effect cleanups run on the passive
+drain that follows `root.unmount()`, so `map.remove()` — and with it the WebGL
+context and worker pool — happens one drain later. Do not assume the map's
+resources are released the instant `unmount()` returns.
+
+**Out of scope.** `react-map-gl/mapbox-legacy` (mapbox-gl v1) and
+`@vis.gl/react-maplibre`.
+
+## Server rendering
+
+`Map` renders its container — with your `style` merged over the binding's
+defaults, so the box is reserved and hydration does not shift the page — and
+omits every child. `mapbox-gl` is imported inside an effect, so nothing on the
+server path touches WebGL or a browser global.
+
+`hydrateRoot` adopts that container rather than replacing it: the map is created
+inside the node the server emitted, so the reserved box, its style and anything
+you rendered around it survive hydration.
+
+## Evidence, and its limits
+
+See [`UPSTREAM.md`](./UPSTREAM.md) for the pin, the full export crosswalk, and
+the disposition of every upstream test file. The short version:
+
+- upstream's five framework-neutral specs run byte-exact against both source
+  trees;
+- upstream's seven component specs need a live Mapbox token and real WebGL under
+  puppeteer, so they are ported against a test double — weaker evidence than a
+  pristine run, and recorded as such;
+- a differential lane runs six fixtures through this binding and through the
+  published `@vis.gl/react-mapbox@8.1.2` on React with that same double, which is
+  what makes the double trustworthy: the map shell and its overlays,
+  `<Source>`/`<Layer>` add-update-remove, in-place popup option edits alongside
+  control add and remove, reaching the map by id from outside it to fly the
+  camera, `useControl` called straight from a consumer module, and a marker
+  choosing between the default pin and a custom element.
+
+Not covered: real WebGL, tile loading, pointer interaction, `reuseMaps`,
+external `gl` contexts, and RTL text plugin loading.

package/UPSTREAM.md

@@ -0,0 +1,216 @@
+# Upstream @vis.gl/react-mapbox audit
+
+This port targets the immutable release `@vis.gl/react-mapbox@8.1.2`:
+
+- repository: `https://github.com/visgl/react-map-gl`;
+- tag: `v8.1.2`, tag object `fb9c6230b59eb0cde25b53a2d82481d83c968866`;
+- tag commit: `b1e46fcfb9d5de9bb179ca54e7d27617caa28c65`;
+- source root: `modules/react-mapbox/src`; test root `modules/react-mapbox/test`;
+- license: MIT, Copyright Vis.gl contributors.
+
+`react-map-gl@8.1.2` is a re-export shell: its `./mapbox` subpath is this
+package, `./maplibre` is `@vis.gl/react-maplibre`, and `./mapbox-legacy` is a
+mapbox-gl v1 compatibility build. The port therefore targets the real source
+package, and publishes both `.` and `./mapbox` so either import works.
+
+The advertised peer range is `mapbox-gl >= 3.5.0`, matching upstream. The
+immutable oracle is `mapbox-gl@3.9.0`, the release upstream develops against.
+`mapbox-gl` is an optional peer and is never vendored: from v2 it ships under
+the Mapbox Terms of Service rather than an OSS license, and it bills per map
+load against an access token.
+
+## Source boundary
+
+Fourteen upstream modules carry no React import and are reused **byte-for-byte**
+under a five-line provenance banner (`@ts-nocheck` plus the reason). Strip the
+banner and the bytes equal `upstream/src/<same path>` exactly, which is what
+makes an upstream bump a readable diff:
+
+- `mapbox/mapbox.ts`, `mapbox/proxy-transform.ts`, `mapbox/create-ref.ts`;
+- `types/common.ts`, `types/events.ts`, `types/internal.ts`, `types/lib.ts`,
+  `types/style-spec.ts`;
+- `utils/assert.ts`, `utils/compare-class-names.ts`, `utils/deep-equal.ts`,
+  `utils/set-globals.ts`, `utils/style-utils.ts`, `utils/transform.ts`.
+
+Upstream compiles without `strictNullChecks` or `noImplicitAny`; this repository
+is strict. Rather than edit vendored source to satisfy a constraint its authors
+never applied, those files carry `@ts-nocheck` and are typechecked at upstream's
+own settings through `upstream/`. Everything the port authors is fully strict.
+
+`upstream/tsconfig.json` is deliberately not vendored: it is vis.gl monorepo
+build config, excluded from the published package by its own `files` field, and
+its `extends` path does not resolve outside that repository.
+
+Everything else is re-implemented against Octane hooks.
+
+## Export crosswalk
+
+Every runtime and type export of `modules/react-mapbox/src/index.ts` at the pin.
+
+| Export | Kind | Disposition | Evidence |
+| --- | --- | --- | --- |
+| `Map` (also `default`) | component | ported | `tests/upstream/map.test.ts` (7 cases), `tests/ssr/ssr.test.ts`, `tests/hydration/hydration.test.ts`, differential |
+| `Marker` | component | ported | `tests/upstream/marker.test.ts` (4 cases), differential |
+| `Popup` | component | ported | `tests/upstream/popup.test.ts` (2 cases), `differential:1`, `differential:3` |
+| `Source` | component | ported, one divergence | `tests/upstream/source-layer.test.ts` (1 case), `differential:2` |
+| `Layer` | component | ported, one divergence | `tests/upstream/source-layer.test.ts` (2 cases), `differential:2` |
+| `AttributionControl` | component | ported | `tests/upstream/controls.test.ts:1` |
+| `FullscreenControl` | component | ported | `tests/upstream/controls.test.ts:2` |
+| `GeolocateControl` | component | ported | `tests/upstream/controls.test.ts:3` |
+| `NavigationControl` | component | ported | `tests/upstream/controls.test.ts:4`, `:7` |
+| `ScaleControl` | component | ported | `tests/upstream/controls.test.ts:5`, `:6` |
+| `useControl` | hook | ported | exercised by all five controls; `:6` pins in-place reconfiguration; `differential:5` pins the consumer-facing hook itself |
+| `MapProvider` | component | ported | `tests/upstream/use-map.test.ts` (2 cases), `differential:4` |
+| `useMap` | hook | ported | `tests/upstream/use-map.test.ts` (2 cases), `differential:4` |
+| `MapProps` | type | ported | `typetests/*/types.test-d.ts` group 1–2 |
+| `MapRef` | type | reused verbatim (`mapbox/create-ref.ts`) | `tests/upstream/map.test.ts:1` |
+| `MarkerProps` | type | ported | type suites group 3–4 |
+| `PopupProps` | type | ported | type suites (shape mirrors `MarkerProps`) |
+| `SourceProps` | type | ported | type suites group 5 |
+| `LayerProps` | type | ported | type suites group 6 |
+| `AttributionControlProps` | type | ported | compiled by the adapted type suite |
+| `FullscreenControlProps` | type | ported | compiled by the adapted type suite |
+| `GeolocateControlProps` | type | ported | compiled by the adapted type suite |
+| `NavigationControlProps` | type | ported | compiled by the adapted type suite |
+| `ScaleControlProps` | type | ported | compiled by the adapted type suite |
+| `export * from './types/common'` | types | reused verbatim | pristine + adapted util lanes |
+| `export * from './types/events'` | types | reused verbatim | pristine + adapted util lanes |
+| `export * from './types/lib'` | types | reused verbatim | pristine + adapted util lanes |
+| `export * from './types/style-spec'` | types | reused verbatim | pristine + adapted util lanes |
+
+### Open gaps
+
+- **`reuseMaps` / `Mapbox.recycle()`** is wired through from the reused engine
+  and typed, but no test exercises the recycle path. It is not covered by
+  upstream's suite either. Treat it as unverified.
+- **`gl` (external WebGL context)**, **`RTLTextPlugin` loading** and
+  **`workerClass`/`workerUrl`** reach the reused `set-globals`/`mapbox` modules
+  unchanged and have no behavioral test here. Upstream has none either.
+- **`react-map-gl/mapbox-legacy`** (mapbox-gl v1) is out of scope, matching the
+  current-major-only decision. Not applicable rather than missing.
+- **`@vis.gl/react-maplibre`** is a separate upstream package and out of scope.
+
+## Test disposition
+
+Every artifact under `modules/react-mapbox/test` at the pin.
+
+| Upstream file | Disposition |
+| --- | --- |
+| `test/utils/apply-react-style.spec.js` | **run byte-exact**, both lanes |
+| `test/utils/compare-class-names.spec.js` | **run byte-exact**, both lanes |
+| `test/utils/deep-equal.spec.js` | **run byte-exact**, both lanes |
+| `test/utils/style-utils.spec.js` | **run byte-exact**, both lanes |
+| `test/utils/transform.spec.js` | **run byte-exact**, both lanes |
+| `test/utils/mapbox-gl-mock/*.js` (5) | vendored; `transform.js`, `lng_lat.js` and `lng_lat_bounds.js` also back the component double |
+| `test/utils/test-utils.jsx` | not applicable — `waitForMapLoad`/`sleep` are replaced by explicit draining |
+| `test/utils/token.js` | not applicable — no live Mapbox token in CI |
+| `test/components/map.spec.jsx` | **ported** → `tests/upstream/map.test.ts`; `Map#uncontrolled` is out of scope (asserts animation monotonicity across a real raf render loop) |
+| `test/components/marker.spec.jsx` | **ported** → `tests/upstream/marker.test.ts` |
+| `test/components/popup.spec.jsx` | **ported** → `tests/upstream/popup.test.ts` |
+| `test/components/source.spec.jsx` | **ported** → `tests/upstream/source-layer.test.ts` |
+| `test/components/layer.spec.jsx` | **ported** → `tests/upstream/source-layer.test.ts` |
+| `test/components/controls.spec.jsx` | **ported** → `tests/upstream/controls.test.ts` |
+| `test/components/use-map.spec.jsx` | **ported** → `tests/upstream/use-map.test.ts` |
+| `test/components/index.js`, `test/utils/index.js` | not applicable — ocular aggregators |
+
+Upstream ships **no type tests** at the pin: there is no `__typetest__`
+directory and no tsd/expect-type harness. Both type lanes are therefore
+port-authored against one shared assertion list (`typetests/assertions.md`), one
+compiled against the published upstream typings with `tsc` and one against this
+package with `tsrx-tsc`. The permitted transformations between them are listed
+in that file; anything else is drift.
+
+## Port-authored test classification
+
+Every test file this package owns, with exactly one classification and the React
+evidence it is paired against. Unpaired files are **not** React-parity evidence
+and are not counted as such by any lane.
+
+| File | Classification | Pairing |
+| --- | --- | --- |
+| `tests/upstream-util/pristine.test.ts` | unmodified upstream | runs upstream's own specs against `upstream/src` |
+| `tests/upstream-util/adapted.test.ts` | unmodified upstream | same specs, same bytes, against the reused modules |
+| `tests/upstream/{map,marker,popup,source-layer,controls,use-map}.test.ts` | adapted upstream | each case cites the upstream case it re-authors |
+| `tests/differential/parity.test.ts` | React/Octane differential | the published `@vis.gl/react-mapbox@8.1.2` on React |
+| `tests/ssr/ssr.test.ts` | Octane-only framework contract | unpaired — upstream ships no SSR test and React's server output is not this port's contract |
+| `tests/hydration/hydration.test.ts` | Octane-only framework contract | unpaired — hydration marker and adoption behavior is Octane's, not upstream's |
+| `tests/runtime/lifecycle.test.ts` | Octane-only divergence | unpaired — pins teardown ordering the upstream suite cannot observe |
+| `tests/runtime/smoke.test.ts` | Octane-only framework contract | unpaired — package surface and entry points |
+| `tests/harness/tape-adapter.test.ts` | harness negative controls | unpaired — proves a removed, renamed or unexecuted upstream case fails validation |
+| `typetests/{pristine,adapted}/types.test-d.ts` | port-authored type lanes | paired with each other through `typetests/assertions.md` |
+
+## How the evidence is bounded
+
+The five util specs are the only upstream tests that run unmodified, and they
+run **twice**: once against `upstream/src` and once against the modules this
+port reuses. Both passing is what backs the byte-for-byte reuse claim.
+
+The seven component specs cannot run as pristine evidence. Each constructs a
+real `mapbox-gl@3` Map with a live `VITE_MAPBOX_TOKEN` and waits on
+`isStyleLoaded()` under puppeteer; CI can hold neither the account nor the map
+loads. They are ported against `tests/_mocks/mapbox-gl.ts`, a port-authored
+double — **weaker evidence than a pristine run, and recorded as such**.
+
+What keeps the double honest is `tests/differential/parity.test.ts`: five
+fixtures run through this binding and through the *published*
+`@vis.gl/react-mapbox@8.1.2` on real React, sharing that same double. A double
+that flattered the Octane binding would have to flatter React identically. They
+cover the map shell and portalled overlay content (`differential:1`),
+`<Source>`/`<Layer>` add, update and remove (`differential:2`), in-place popup
+option edits alongside control add and remove (`differential:3`), and reaching
+the map by id from a component outside it and flying the camera
+(`differential:4`), and `useControl` called straight from a consumer module
+(`differential:5`).
+
+`<Source>` and `<Layer>` emit no DOM, so `differential:2` reads the resulting
+style back off the live map through `useMap()` and renders it into the page —
+the comparison is then over what each binding told mapbox-gl to do, not over
+markup neither of them produces.
+
+Not covered by any of this: real WebGL, real tile loading, real pointer
+interaction, and anything that needs a Mapbox account. A token-gated real-map
+lane remains open work.
+
+## Divergences
+
+Four, two of them recorded in `audit/react-parity.json` and bound to a case:
+
+1. **`react-map-gl-source-id-by-context`** — upstream delivers a `<Source>` id to
+   child layers with `cloneElement(child, {source: id})`. Octane cannot clone a
+   compiled children block, so the id travels by context. Same override
+   semantics; the id now reaches any descendant `<Layer>`, not only direct
+   children. `ported:source-layer:3` pins the half both models share — a layer
+   inherits the generated id and an explicit `source` still loses to the
+   enclosing one — with a direct child, so it cannot observe the half where they
+   part. `tests/runtime/source-context.test.ts` mounts a layer below a wrapper
+   component, which is the shape `cloneElement` would have missed.
+2. **`react-map-gl-refs-as-props`** — `forwardRef` does not exist in Octane, so
+   `Map`, `Marker`, `Popup` and `GeolocateControl` take `ref` as a plain prop.
+   `<Map ref={mapRef} />` is unchanged for consumers.
+3. **Teardown timing** — effect cleanups run on the passive drain after
+   `root.unmount()`, not inside it, so the map's WebGL context and workers are
+   released one drain later. This is an Octane runtime property rather than a
+   binding behavior and no parity lane observes it, so it is deliberately not a
+   manifest divergence; it is pinned by `tests/runtime/lifecycle.test.ts`.
+4. **`Marker` element chosen from rendered output** — upstream asks
+   `React.Children.forEach` whether it was handed a truthy child and, if so,
+   gives the marker its own element to portal into. A `.tsrx` children block is
+   an opaque render function, and evaluating it to look inside would re-run any
+   hooks it contains against the same call-site slots, so the binding infers the
+   answer from what the block rendered instead. It portals into an element it
+   owns from the first render — never `marker.getElement()`, or content arriving
+   late would land inside Mapbox's pin and both would draw — and rebuilds the
+   marker once the answer is known, in either direction. Same result as upstream
+   for a block that renders something and for one that renders nothing, and for
+   content that appears after mount. It differs for a child that is truthy but
+   renders nothing for the component's whole life: upstream leaves an empty
+   custom element, so the marker is invisible, and the port draws the default
+   pin. Pinned by `tests/runtime/marker-element.test.ts` and, against real
+   React, by `differential:6`.
+
+## Regenerating
+
+`node scripts/generate-parity-manifest.mjs` rebuilds `audit/react-parity.json`
+and the runtime inventories from actual Vitest runs. Editing a lane file without
+rerunning it fails `pnpm react-parity:check` on the integrity hash, which is the
+point.

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@octanejs/react-map-gl",
+  "version": "0.0.1",
+  "license": "MIT",
+  "type": "module",
+  "sideEffects": false,
+  "engines": {
+    "node": ">=22.22.2"
+  },
+  "description": "Mapbox GL JS bindings for Octane — a port of @vis.gl/react-mapbox, the package react-map-gl/mapbox re-exports.",
+  "author": {
+    "name": "Dominic Gannaway",
+    "email": "dg@domgan.com"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/octanejs/octane.git",
+    "directory": "packages/react-map-gl"
+  },
+  "main": "src/index.ts",
+  "module": "src/index.ts",
+  "types": "src/index.ts",
+  "files": [
+    "src",
+    "LICENSE",
+    "README.md",
+    "UPSTREAM.md"
+  ],
+  "exports": {
+    ".": "./src/index.ts",
+    "./mapbox": "./src/index.ts"
+  },
+  "peerDependencies": {
+    "mapbox-gl": ">=3.5.0",
+    "octane": "0.1.29"
+  },
+  "peerDependenciesMeta": {
+    "mapbox-gl": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@mapbox/point-geometry": "1.1.0",
+    "@tsrx/react": "^0.2.56",
+    "@types/react": "^19.2.17",
+    "@types/react-dom": "^19.2.3",
+    "@vis.gl/react-mapbox": "8.1.2",
+    "esbuild": "^0.28.1",
+    "mapbox-gl": "3.9.0",
+    "react": "^19.2.7",
+    "react-dom": "^19.2.7",
+    "vitest": "^4.1.10",
+    "octane": "0.1.29"
+  },
+  "scripts": {
+    "test": "vitest run --root ../.. --project react-map-gl"
+  }
+}

package/src/components/attribution-control.ts

@@ -0,0 +1,27 @@
+import { memo, useEffect } from 'octane';
+import { applyReactStyle } from '../utils/apply-react-style';
+import { useControl } from './use-control';
+
+import type { ControlPosition, AttributionControlOptions } from '../types/lib';
+import type { CSSProperties } from '../types/octane';
+
+export type AttributionControlProps = AttributionControlOptions & {
+	/** Placement of the control relative to the map. */
+	position?: ControlPosition;
+	/** CSS style override, applied to the control's container */
+	style?: CSSProperties;
+};
+
+function _AttributionControl(props: AttributionControlProps) {
+	const ctrl = useControl(({ mapLib }) => new mapLib.AttributionControl(props), {
+		position: props.position,
+	});
+
+	useEffect(() => {
+		applyReactStyle(ctrl._container, props.style);
+	}, [props.style]);
+
+	return null;
+}
+
+export const AttributionControl = memo(_AttributionControl);

package/src/components/fullscreen-control.ts

@@ -0,0 +1,35 @@
+/* global document */
+import { memo, useEffect } from 'octane';
+import { applyReactStyle } from '../utils/apply-react-style';
+import { useControl } from './use-control';
+
+import type { ControlPosition, FullscreenControlOptions } from '../types/lib';
+import type { CSSProperties } from '../types/octane';
+
+export type FullscreenControlProps = Omit<FullscreenControlOptions, 'container'> & {
+	/** Id of the DOM element which should be made full screen. By default, the map container
+	 * element will be made full screen. */
+	containerId?: string;
+	/** Placement of the control relative to the map. */
+	position?: ControlPosition;
+	/** CSS style override, applied to the control's container */
+	style?: CSSProperties;
+};
+
+function _FullscreenControl(props: FullscreenControlProps) {
+	const ctrl = useControl(
+		({ mapLib }) =>
+			new mapLib.FullscreenControl({
+				container: props.containerId ? document.getElementById(props.containerId) : undefined,
+			}),
+		{ position: props.position },
+	);
+
+	useEffect(() => {
+		applyReactStyle(ctrl._controlContainer, props.style);
+	}, [props.style]);
+
+	return null;
+}
+
+export const FullscreenControl = memo(_FullscreenControl);

package/src/components/geolocate-control.ts

@@ -0,0 +1,88 @@
+import { memo, useEffect, useImperativeHandle, useRef } from 'octane';
+import { applyReactStyle } from '../utils/apply-react-style';
+import { useControl } from './use-control';
+
+import type {
+	ControlPosition,
+	GeolocateControlInstance,
+	GeolocateControlOptions,
+} from '../types/lib';
+import type { GeolocateEvent, GeolocateResultEvent, GeolocateErrorEvent } from '../types/events';
+import type { CSSProperties, Ref } from '../types/octane';
+
+export type GeolocateControlProps = GeolocateControlOptions & {
+	/** Placement of the control relative to the map. */
+	position?: ControlPosition;
+	/** CSS style override, applied to the control's container */
+	style?: CSSProperties;
+
+	/** Called on each Geolocation API position update that returned as success. */
+	onGeolocate?: (e: GeolocateResultEvent) => void;
+	/** Called on each Geolocation API position update that returned as an error. */
+	onError?: (e: GeolocateErrorEvent) => void;
+	/** Called on each Geolocation API position update that returned as success but user position
+	 * is out of map `maxBounds`. */
+	onOutOfMaxBounds?: (e: GeolocateResultEvent) => void;
+	/** Called when the GeolocateControl changes to the active lock state. */
+	onTrackUserLocationStart?: (e: GeolocateEvent) => void;
+	/** Called when the GeolocateControl changes to the background state. */
+	onTrackUserLocationEnd?: (e: GeolocateEvent) => void;
+	/** Octane passes refs as ordinary props; there is no forwardRef. */
+	ref?: Ref<GeolocateControlInstance>;
+};
+
+function _GeolocateControl(props: GeolocateControlProps) {
+	const thisRef = useRef({ props });
+
+	const ctrl = useControl(
+		({ mapLib }) => {
+			const gc = new mapLib.GeolocateControl(props);
+
+			// Hack: fix GeolocateControl reuse
+			// GeolocateControl's UI creation is asynchronous. Removing and adding it back
+			// causes the UI to be initialized twice.
+			//
+			// Upstream reaches for this because React strict mode mounts the component
+			// twice. Octane has no StrictMode double-invoke, so the guard is inert here;
+			// it is kept because it is also correct for an ordinary remount, and deleting
+			// upstream behavior on a technicality is how ports drift.
+			const setupUI = gc._setupUI.bind(gc);
+			gc._setupUI = (args) => {
+				if (!gc._container.hasChildNodes()) {
+					setupUI(args);
+				}
+			};
+
+			gc.on('geolocate', (e) => {
+				thisRef.current.props.onGeolocate?.(e as GeolocateResultEvent);
+			});
+			gc.on('error', (e) => {
+				thisRef.current.props.onError?.(e as GeolocateErrorEvent);
+			});
+			gc.on('outofmaxbounds', (e) => {
+				thisRef.current.props.onOutOfMaxBounds?.(e as GeolocateResultEvent);
+			});
+			gc.on('trackuserlocationstart', (e) => {
+				thisRef.current.props.onTrackUserLocationStart?.(e as GeolocateEvent);
+			});
+			gc.on('trackuserlocationend', (e) => {
+				thisRef.current.props.onTrackUserLocationEnd?.(e as GeolocateEvent);
+			});
+
+			return gc;
+		},
+		{ position: props.position },
+	);
+
+	thisRef.current.props = props;
+
+	useImperativeHandle(props.ref, () => ctrl, []);
+
+	useEffect(() => {
+		applyReactStyle(ctrl._container, props.style);
+	}, [props.style]);
+
+	return null;
+}
+
+export const GeolocateControl = memo(_GeolocateControl);