open-industries 0.1.0__tar.gz

open_industries-0.1.0/PKG-INFO

@@ -0,0 +1,171 @@
+Metadata-Version: 2.4
+Name: open-industries
+Version: 0.1.0
+Summary: Static Open Industries scene exporter for georeferenced 3D Tiles
+Author: Mapped Assembly
+License: MIT License
+        
+        Copyright (c) 2026 Isayah Culbertson
+        
+        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.
+        
+Project-URL: Homepage, https://github.com/Mapped-Assembly/Open-Industries
+Project-URL: Repository, https://github.com/Mapped-Assembly/Open-Industries
+Project-URL: Issues, https://github.com/Mapped-Assembly/Open-Industries/issues
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# Static OI scenes → 3D Tiles 1.1
+
+A small, independently runnable Python converter and local CesiumJS/Three.js
+interoperability demo for [issue #18](https://github.com/Mapped-Assembly/Open-Industries/issues/18).
+It consumes the geometry already bundled in a portable OI scene. It does not
+tessellate CAD, perform physics, or build a general-purpose streaming hierarchy.
+
+## Reproduce
+
+Python 3.11+ is sufficient for conversion and contract tests. The separate
+viewer/validator package uses Node 22.18+ and a committed npm lockfile. Root
+application dependencies and provider credentials are unnecessary.
+
+From the repository root:
+
+```sh
+python tools/geospatial/export_scene.py benchmarks/field-lab/fixtures/field-lab.oi.json tools/geospatial/public/export --longitude=-73.977 --latitude=40.684 --height=30 --heading=0 --license-note="Existing conceptual FIELD-LAB fixture; redistribution permission unresolved"
+python -m unittest discover -s tools/geospatial -p test_export.py -v
+cd tools/geospatial
+npm ci --ignore-scripts
+npx playwright install chromium
+npm run validate
+npm run test:browser
+npm run serve
+```
+
+Open <http://127.0.0.1:4194/> for CesiumJS or
+<http://127.0.0.1:4194/?viewer=three> for the independent 3D Tiles renderer.
+The server is local; nothing is published or deployed. Both runtimes load the
+same local tileset without Cesium ion, imagery, login, or tokens. Dependencies
+and browsers need network access during installation only.
+
+`--ignore-scripts` avoids unused native SQLite build hooks pulled in by the
+validator's archive tooling. This adapter validates directory-based JSON/GLB,
+not SQLite tile archives. The pinned sharp override supplies platform packages
+instead of the old validator dependency's legacy installation hook. Runtime
+dependencies retain their own licenses.
+
+## Coordinate contract
+
+- Input is `astra.scene` v1, meters, right-handed Y-up. OI rotations use
+  Three.js Euler XYZ in degrees.
+- At heading zero, OI +X is east, +Y is up, and -Z is north. The caller explicitly
+  supplies WGS84 longitude, latitude, **ellipsoidal** height, and heading.
+  Heading rotates clockwise from true north, in [0, 360).
+- GLB positions remain Y-up. A 3D Tiles runtime applies the standard Y-up→Z-up
+  rotation `C`, mapping (x,y,z) to (x,-z,y). Child transforms are
+  `C × OI_pose × inverse(C)`. The root is WGS84 ENU→ECEF with heading.
+  Tile bounds are Z-up; all serialized matrices are column-major.
+  The empty root uses a conservative extent-sized geometric error to request
+  refinement; exact leaf geometry has zero geometric error.
+- Stored mesh vertices are already normalized and stored instance positions
+  already locate those normalized origins. **Do not add originOffset again.**
+  The offset is retained as source provenance.
+- The Three.js viewer recenters the ECEF scene into the original local meter
+  frame for numerical precision. It loads the identical geographic tileset.
+- Geographic anchors are illustrative. The converter does not fetch terrain,
+  infer ground height, geocode a lab, or establish surveyed accuracy.
+
+## Data and metadata mapping
+
+| Input | Output |
+| --- | --- |
+| Indexed part geometry and linear RGB | Shared-asset GLBs with unlit, double-sided materials |
+| Visible instance placement/rotation | One leaf tile per instance; same asset content reused |
+| Asset ID/name and source digest | glTF EXT_mesh_features + EXT_structural_metadata property table |
+| Instance ID/name, asset ID, source kind/digest | 3D Tiles tile metadata; inherited when geometry is picked |
+| Project identity/revision, cloud binding, source normalization offset, part IDs | Allowlisted provenance.json sidecar |
+| Input file byte digest and checkout revision | Export report and provenance; revision is null outside Git |
+| Hidden geometry, animation, hierarchy grouping, BOM/compiler findings, source documents, room decoration | Explicitly excluded; no claim of lossless IR transfer |
+
+There is no static feature ID per animated component: all primitives of a shared
+asset refer to its single asset feature. Part identities are preserved in node
+extras and the sidecar. Instance identity belongs to the leaf tile and remains
+distinct when two instances share one GLB. Arbitrary provider settings, raw IR,
+source documents and credentials are not copied; this allowlist is stricter than
+the full OI portable export. It cannot detect secrets pasted into an allowed name.
+
+## Validation and evidence
+
+The converter writes tileset.json, content-addressed GLBs, provenance.json and
+export-report.json with source/output hashes, Python version, payload size and
+conversion timing. Existing unrelated files in the output directory are not
+deleted; the report and validators enumerate only current referenced content.
+Use a fresh output directory for a distributable package.
+
+`npm run validate` records complete diagnostics from 3d-tiles-validator 0.6.1
+and gltf-validator 2.0.0-dev.3.10. The latter reports metadata extensions as
+unsupported informational messages; the 3D Tiles validator additionally checks
+those extensions. Zero core errors alone is not proof that every extension or
+engineering property is valid.
+
+`npm run test:browser` starts and closes its own Vite server, verifies placement
+against independent Cesium WGS84/ENU and Three.js Euler implementations within
+1 cm, loads both runtimes, and clicks pipette geometry to check exact identity.
+It saves screenshots, browser/runtime versions, load timing, and memory metrics
+under evidence/. External browser requests are blocked in this test.
+
+The workflow runs Python checks on Linux/Windows and viewer/conformance checks
+at two demonstration anchors on Linux. Screenshots, validator diagnostics,
+checksums, geometry, and timing are uploaded as CI artifacts. Load/capture timing
+on a software-rendered browser is not interactive FPS or physical performance.
+
+The upstream FIELD-LAB merge has passing [benchmark](https://github.com/Mapped-Assembly/Open-Industries/actions/runs/37550844141),
+[scene](https://github.com/Mapped-Assembly/Open-Industries/actions/runs/37550844134),
+and [runtime](https://github.com/Mapped-Assembly/Open-Industries/actions/runs/37550844184)
+workflows at e88f5ce5f8eeb4eda6a49757d5325699cd815cea.
+Adapter CI is separate and must be checked at the published PR head.
+
+## Openness and limits
+
+The new source/documents in **this tools/geospatial directory** are MIT licensed.
+That license does not relicense the repository, imported FIELD-LAB or cleanroom
+assets, dependencies, or generated models. `--license-note` records the user's
+evidence or unresolved status; it does not grant permission or certify rights.
+Confirm original asset permissions before redistributing a grant demonstration.
+
+For a fully MIT-licensed interchange fixture, use
+`fixtures/open-equipment.oi.json`: two instances of a newly authored asymmetric
+workbench envelope, including a 90-degree rotation and shared geometry. Its
+conceptual boxes do not reuse the existing lab/CAD assets. Substitute that input
+in the converter command and set `--license-note="MIT; tools/geospatial/LICENSE"`.
+The browser smoke test specifically targets the 21-instance FIELD-LAB fixture;
+the minimal fixture can be inspected manually and checked with the validators.
+
+This first version exports the **static base layout**, not frame zero of the
+authored animation. No animation, scientific validity, perception, provider
+generation, cold-chain solver, live operation, or physical validation is implied.
+The small FIELD-LAB fixture is not a scalability benchmark. A state/replay
+overlay and resolved asset licensing remain follow-on work; issue #18 should
+stay open until its remaining evidence gates are addressed.

open_industries-0.1.0/README.md

@@ -0,0 +1,201 @@
+# Mergence
+
+**Arrange hardware in a 3D space, animate how it moves, and share the layout for review.**
+
+Mergence is a spatial workbench that runs locally in your browser for planning fabrication shops, manufacturing spaces, and laboratories. Import equipment from [Form](https://github.com/caid-technologies/Form-OSS) or a STEP CAD file, place it in a room at real-world scale, and preview a workflow before moving physical equipment.
+
+[Run locally](#run-locally) · [Try the local demo](#try-the-local-demo) · [Documentation](#documentation)
+
+## Why use it?
+
+A hardware model describes an individual piece of equipment. Planning a workspace also means deciding where that equipment goes, what sits around it, and how people or materials move through the room.
+
+Mergence brings those models into one editable scene. A maker can compare workbench arrangements, a manufacturing team can illustrate material flow, and a lab team can review an equipment layout or sampling route. The output is a room layout, an animation, and files that others can reopen or review.
+
+## Try the local demo
+
+Follow [Run locally](#run-locally) to install the project and start `npm run dev`, then open the [cleanroom demo](http://127.0.0.1:5173/?scene=cleanroom). It includes four rooms, stainless workbenches, and a Form-authored swab-sampling robot. The animation visits Rooms A and C and skips occupied Room B, showing how equipment, space, and a schedule fit together. The demo opens without replacing your saved workspace.
+
+To make your own layout, open the [local workbench](http://127.0.0.1:5173):
+
+1. Choose **Space brief / local demo**, select a maker, manufacturing, or biofab space, and click **Build space layout**. This creates a preset layout with labeled equipment placeholders and a material-flow animation.
+2. Or choose **Import project** / **Drop files or browse** to open your own Form JSON, STEP model, or saved Mergence scene.
+3. Adjust the room and equipment, then use **Animate**, **GIF studio**, or **Export scene JSON** to inspect and share the result.
+
+You can import, edit, animate, and export locally without signing in. Optional cloud features use GitHub sign-in and a configured Supabase backend; the workbench itself runs on your machine.
+
+## What you can do today
+
+| Capability | What it does |
+| --- | --- |
+| Import equipment | Open Form project JSON and `.step` / `.stp` CAD files, with geometry normalized to meters. |
+| Arrange a room | Set width, depth, and height; move, rotate, rename, duplicate, hide, or remove equipment instances; undo and redo edits. |
+| Inspect a design | View available components, bill of materials (BOM), validation findings, and source/project metadata. |
+| Author motion | Add position and rotation keyframes for equipment or components, then play or scrub the timeline. |
+| Export a visual review | Render GIFs of a room, a floor section, or a selected asset, with companion JSON recording spatial and animation context. |
+| Reuse equipment | Save geometry and previews in a device asset library and add them to another layout. |
+| Save and reopen | Export portable scene JSON, restore local drafts, or save named cloud scenes with revision history, comparison, and restore. |
+| Work with agents locally | Use optional Form/MCP workflows to author equipment, create or revise saved scenes from an external agent, and return animation feedback to Form. |
+
+## How Form and Mergence work together
+
+### Generate and transfer projects in OpenIndustries
+
+- **Generate Forma project → Build with Form** checks the local Forma installation before enabling generation. Choose **Deterministic demo** for a sample without credentials, or **Live generation** with your server-configured provider and model. The resulting equipment is added to the current room, with its design, BOM, and validation data retained.
+- **Export selected Forma project** downloads the selected equipment as `.forma.json`, using the same Hardware IR shape as Forma's JSON export. Referenced STEP/CAD files remain separate; room placement and animation belong to the OI project.
+- **Export OI project** downloads a portable `.oi.json` containing the room, available equipment geometry, instance names/transforms/visibility, retained Forma design data, and animation. **Import OI project** opens it on a fresh browser without an account. Unsaved room changes are protected by the existing save/discard/cancel prompt.
+- Existing `mergence-scene.json` and `astra.scene` v1 files still open. The **Export scene JSON** action uses the same portable OI export. Missing geometry remains marked missing; exporting cannot restore unavailable source files.
+
+**Hosted generation:** the current Vercel build serves only the browser app; it does not run the Node/Python generator. It supports both project file workflows. Generation controls explain how to use the local workbench instead of silently disappearing. See [local generation setup](docs/development.md#local-form-generation).
+
+**Form authors the equipment; Mergence places and reviews it in a space.** Form OSS provides hardware generation, validation, and compiled project data. Mergence imports that output and adds room layout, instance placement, animation, and visual review.
+
+1. **Create or bring equipment.** Author and compile a project in Form, or use an existing STEP file from another CAD tool.
+2. **Import it into Mergence.** Select the Form JSON and any referenced STEP files together. Standalone STEP files also work.
+3. **Arrange and animate.** Place equipment in the room and add keyframes to illustrate its motion or a workflow.
+4. **Save or share.** Export a portable scene, render a GIF plus review metadata, or save a cloud scene.
+5. **Iterate when needed.** In the optional local agent workflow, send animation feedback to Form, review the revised design, and reimport its compiled artifact.
+
+An **asset** is reusable imported equipment geometry. An **instance** is one placed copy of that asset. A **scene** combines the room, instances, and animation. Multiple instances can share one asset while keeping independent positions and motion.
+
+See the [workspace guide](docs/workspace.md) for the full editing workflow and the [Form handoff contract](docs/form-handoff.md) for supported project formats.
+
+## Saving your work
+
+| Option | Where it lives | Best for |
+| --- | --- | --- |
+| Automatic local draft | The current browser/device | Returning to work after a refresh. This is separate from a cloud save. |
+| Device asset library | The current browser/device | Reusing equipment and its GIF previews across layouts. |
+| Portable scene JSON | A file you export | Reopening or transferring a scene with its geometry and animation, without cloud services. |
+| Cloud scene | Your signed-in Supabase account | Saving named scenes across devices. Enable **Include cloud geometry** when saving if the other device needs the models. |
+| Cloud files | Optional private Supabase Storage | Explicitly uploading geometry bundles, GIF previews, and supported source attachments. |
+
+Browser storage is subject to quota and eviction, so export a scene file for a portable copy. Signing in does not automatically upload your imported files. A metadata-only cloud scene may show missing-geometry placeholders on another device until you provide the source assets. See [cloud storage setup](docs/cloud-storage.md) for enabling geometry transfers.
+
+## Run locally
+
+### Browser workbench
+
+Install **Node.js 22** and Git, then run:
+
+```bash
+git clone https://github.com/caid-technologies/Form-Industries.git
+cd Form-Industries
+npm ci
+npm run dev
+```
+
+Open <http://127.0.0.1:5173>. The development command starts both Vite and the local API server. To view the bundled example, open <http://127.0.0.1:5173/?scene=cleanroom>.
+
+Python, provider API keys, and Supabase configuration are optional for local imports, room editing, animation, the device library, and exports.
+
+To serve a production build locally:
+
+```bash
+npm run build
+npm start
+```
+
+Open <http://127.0.0.1:8787>.
+
+### Optional services
+
+Copy [`.env.example`](.env.example) to `.env` when you need configuration. Restart development or rebuild after changing browser variables.
+
+| Feature | Setup |
+| --- | --- |
+| Local **Build with Form** | Install Python 3.11+ and `requirements-form.txt` into `.venv`. Follow the [local generation guide](docs/development.md#local-form-generation), then try **Deterministic demo** without provider credentials. |
+| Live Form generation | Configure server-side provider credentials in `.env` and select a provider/model in the UI. Live provider calls have not yet been verified in this project. |
+| GitHub sign-in and cloud scenes | Configure Supabase Auth/Postgres and set `VITE_SUPABASE_URL` and `VITE_SUPABASE_PUBLISHABLE_KEY`. See [Auth/database setup](supabase/README.md). |
+| Private cloud geometry and GIFs | Apply the storage migrations and set `VITE_CLOUD_STORAGE_ENABLED=true`. See the [storage guide](docs/cloud-storage.md). |
+| Disable local generation | Set `VITE_FORM_GENERATION_ENABLED=false` for browser-only deployments. The generation panel explains local setup; import/export stays available. |
+| Local agents and CLI | See [OpenCode/MCP setup](docs/development.md#optional-form-mcp-demo), [scene authoring through MCP](docs/mcp-scenes.md), and the [Mergence CLI](docs/development.md#astra-cli). |
+
+Only public Supabase browser configuration belongs in `VITE_` variables. Provider credentials and Supabase service-role keys must stay out of the browser bundle.
+
+## Technology and repository map
+
+| Part | Technology | Location |
+| --- | --- | --- |
+| Browser interface | React 19, TypeScript, Vite | [`src/main.tsx`](src/main.tsx), [`src/components/`](src/components/) |
+| 3D workspace and animation | Three.js | [`src/lib/`](src/lib/), [`src/components/workspace-viewer.tsx`](src/components/workspace-viewer.tsx) |
+| STEP conversion | `occt-import-js` / OpenCascade WebAssembly in a worker | [`src/lib/step.ts`](src/lib/step.ts), [`public/step-worker.js`](public/step-worker.js) |
+| GIF export | `gifenc`, rendered in the browser | [`src/lib/gif.ts`](src/lib/gif.ts) |
+| Cloud accounts and persistence | Supabase Auth, Postgres, optional private Storage | [`supabase/`](supabase/), [`src/lib/scene-repository.ts`](src/lib/scene-repository.ts) |
+| Local Form bridge and agent tools | Node.js/Express, Python `caid-forma-core==0.3.5`, MCP | [`server/`](server/), [`opencode.json`](opencode.json) |
+| Room transfer CLI | Node.js | [`cli/astra.mjs`](cli/astra.mjs) |
+| Verification and examples | Model tests, browser smoke tests, bundled scenes | [`scripts/`](scripts/), [`public/examples/cleanroom/`](public/examples/cleanroom/) |
+
+## Current scope and limitations
+
+Mergence is a working prototype for spatial planning and visual review. Keep these boundaries in mind when evaluating the demo:
+
+- **Animation is visual.** Keyframes illustrate movement; they do not provide physics simulation, collision guarantees, electrical revalidation, or manufacturing approval.
+- **Space briefs use presets and planning envelopes.** These placeholders represent equipment positions and sizes. Replace them with Form-authored projects or CAD for detailed review.
+- **The cleanroom route is illustrative.** Its access schedule is example data, and the mostly fused robot CAD uses whole-robot approach/retract motion to approximate sampling. See the [example notes](public/examples/cleanroom/README.md).
+- **Imports have practical limits.** Equipment imports are capped at 25 MiB per file, 75 MiB per batch, and 2 million vertices per asset. Large assemblies and STEP variants still need broader validation.
+- **Companion CAD must be selected explicitly.** Mergence does not automatically fetch remote CAD URLs or server-local paths. Missing CAD uses labeled envelopes when the project provides them, or reports an error.
+- **Agent integration is optional and local.** The local workbench supports imports and visual review; the Form generation and feedback bridge uses the local API server. Design changes go through an explicit review and reimport loop.
+
+## Development checks
+
+For the TypeScript build and model/contract checks:
+
+```bash
+npm run build
+npm run test:cad
+npm run test:scene
+npm run test:workspace
+npm run test:mcp
+npm run test:mcp-scenes
+npm run test:scene-history
+npm run test:mcp-agent-workflows
+```
+
+For browser smoke tests, run `npm start` in another terminal after building, then run `npm test`, `npm run test:gif`, or `npm run test:fullscreen`. These need Chrome. The main `npm test` suite also needs the Python Form installation and network access for a STEP fixture; the GIF suite does not need those two dependencies. Screenshots go to `test-results/`.
+
+Live cloud tests need a dedicated Supabase test project and test-only credentials; follow the [workspace](docs/workspace.md#verification) and [storage](docs/cloud-storage.md#verification) guides.
+
+## Publishing packages
+
+The repository publishes two distributions from a GitHub Release:
+
+- [`mergence`](https://www.npmjs.com/package/mergence) is the npm package for the browser workbench and local CLI.
+- [`open-industries`](https://pypi.org/project/open-industries/) is the Python package for the static geospatial scene exporter. Its CLI is `oi-export-scene`.
+
+The `Publish packages` workflow validates both builds before publishing. Add a current npm automation token as the repository `NPM_TOKEN` secret, and configure a PyPI trusted publisher for the `pypi` environment, before creating the first release. Package versions are taken from `package.json` and `pyproject.toml`; update both together, then publish a GitHub Release for that version.
+
+## Documentation
+
+- [Workspace guide](docs/workspace.md) — editing, animation, persistence, missing-geometry recovery, and the inspector.
+- [Geospatial interchange](tools/geospatial/README.md) — static OI scenes to 3D Tiles 1.1, CesiumJS and an independent Three.js viewer, with geographic placement and provenance checks.
+- [Form handoff contract](docs/form-handoff.md) — compiled artifacts, supported formats, provenance, and CAD resolution.
+- [Revision history and restore](docs/scene-history.md) — compare saved versions, restore a new head, and preserve exact geometry bindings.
+- [Cross-agent walkthrough](docs/mcp-agent-workflows.md) — deterministic Grok/ChatGPT/Codex fixtures, local agent setup, and create/update/reopen commands.
+- [External-agent scene authoring](docs/mcp-scenes.md) — MCP setup, typed tools, revision URLs, and the deterministic cleanroom fixture.
+- [Authoritative city-dump runtime](docs/mcp-game-runtime.md) — authenticated two-player matches, private material inspection, durable processing and database scheduler setup.
+- [Development and integration guide](docs/development.md) — local generation, MCP, CLI, import contracts, and GIF details.
+- [Scene links](docs/scene-links.md) — private scene/revision URLs, expiring shared links, and deployment steps.
+- [Cloud storage guide](docs/cloud-storage.md) — private asset transfers, setup, limits, and lifecycle.
+- [Supabase Auth and database setup](supabase/README.md) — schema, GitHub login, migrations, and ownership checks.
+- [Cleanroom example](public/examples/cleanroom/README.md) — scene behavior, source models, and CAD licensing.
+
+## Third-party software
+
+Form OSS / Form Core is used under **MPL-2.0**; preserve applicable notices and obligations when reusing upstream code. STEP conversion uses `occt-import-js` and its OpenCascade/WebAssembly distribution; retain their bundled license notices. GIF encoding uses `gifenc` (MIT), and the test decoder is `omggif` (MIT).
+
+The cleanroom robot and workbench source projects declare their mechanical CAD under **CERN-OHL-S-2.0**; see the [example provenance notes](public/examples/cleanroom/README.md). Upstream STEP test geometry is fetched by the smoke test rather than bundled in this repository.
+
+## Citation
+
+If you use OpenIndustries / Mergence in research, publications, or other academic work, please cite the project:
+
+```bibtex
+@software{mapped_assembly_open_industries_2026,
+  author = {{Mapped Assembly}},
+  title = {OpenIndustries (Mergence): Spatial workbench for hardware and manufacturing-system planning},
+  year = {2026},
+  url = {https://github.com/Mapped-Assembly/Open-Industries},
+  note = {Open-source software}
+}
+```

open_industries-0.1.0/pyproject.toml

@@ -0,0 +1,34 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "open-industries"
+version = "0.1.0"
+description = "Static Open Industries scene exporter for georeferenced 3D Tiles"
+readme = {file = "tools/geospatial/README.md", content-type = "text/markdown"}
+license = {file = "tools/geospatial/LICENSE"}
+requires-python = ">=3.11"
+authors = [{name = "Mapped Assembly"}]
+dependencies = []
+classifiers = [
+  "Development Status :: 4 - Beta",
+  "Intended Audience :: Developers",
+  "License :: OSI Approved :: MIT License",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
+]
+
+[project.urls]
+Homepage = "https://github.com/Mapped-Assembly/Open-Industries"
+Repository = "https://github.com/Mapped-Assembly/Open-Industries"
+Issues = "https://github.com/Mapped-Assembly/Open-Industries/issues"
+
+[project.scripts]
+oi-export-scene = "export_scene:main"
+
+[tool.setuptools]
+package-dir = {"" = "tools/geospatial"}
+py-modules = ["export_scene"]

open_industries-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

open_industries-0.1.0/tools/geospatial/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Isayah Culbertson
+
+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.

open_industries-0.1.0/tools/geospatial/README.md

@@ -0,0 +1,131 @@
+# Static OI scenes → 3D Tiles 1.1
+
+A small, independently runnable Python converter and local CesiumJS/Three.js
+interoperability demo for [issue #18](https://github.com/Mapped-Assembly/Open-Industries/issues/18).
+It consumes the geometry already bundled in a portable OI scene. It does not
+tessellate CAD, perform physics, or build a general-purpose streaming hierarchy.
+
+## Reproduce
+
+Python 3.11+ is sufficient for conversion and contract tests. The separate
+viewer/validator package uses Node 22.18+ and a committed npm lockfile. Root
+application dependencies and provider credentials are unnecessary.
+
+From the repository root:
+
+```sh
+python tools/geospatial/export_scene.py benchmarks/field-lab/fixtures/field-lab.oi.json tools/geospatial/public/export --longitude=-73.977 --latitude=40.684 --height=30 --heading=0 --license-note="Existing conceptual FIELD-LAB fixture; redistribution permission unresolved"
+python -m unittest discover -s tools/geospatial -p test_export.py -v
+cd tools/geospatial
+npm ci --ignore-scripts
+npx playwright install chromium
+npm run validate
+npm run test:browser
+npm run serve
+```
+
+Open <http://127.0.0.1:4194/> for CesiumJS or
+<http://127.0.0.1:4194/?viewer=three> for the independent 3D Tiles renderer.
+The server is local; nothing is published or deployed. Both runtimes load the
+same local tileset without Cesium ion, imagery, login, or tokens. Dependencies
+and browsers need network access during installation only.
+
+`--ignore-scripts` avoids unused native SQLite build hooks pulled in by the
+validator's archive tooling. This adapter validates directory-based JSON/GLB,
+not SQLite tile archives. The pinned sharp override supplies platform packages
+instead of the old validator dependency's legacy installation hook. Runtime
+dependencies retain their own licenses.
+
+## Coordinate contract
+
+- Input is `astra.scene` v1, meters, right-handed Y-up. OI rotations use
+  Three.js Euler XYZ in degrees.
+- At heading zero, OI +X is east, +Y is up, and -Z is north. The caller explicitly
+  supplies WGS84 longitude, latitude, **ellipsoidal** height, and heading.
+  Heading rotates clockwise from true north, in [0, 360).
+- GLB positions remain Y-up. A 3D Tiles runtime applies the standard Y-up→Z-up
+  rotation `C`, mapping (x,y,z) to (x,-z,y). Child transforms are
+  `C × OI_pose × inverse(C)`. The root is WGS84 ENU→ECEF with heading.
+  Tile bounds are Z-up; all serialized matrices are column-major.
+  The empty root uses a conservative extent-sized geometric error to request
+  refinement; exact leaf geometry has zero geometric error.
+- Stored mesh vertices are already normalized and stored instance positions
+  already locate those normalized origins. **Do not add originOffset again.**
+  The offset is retained as source provenance.
+- The Three.js viewer recenters the ECEF scene into the original local meter
+  frame for numerical precision. It loads the identical geographic tileset.
+- Geographic anchors are illustrative. The converter does not fetch terrain,
+  infer ground height, geocode a lab, or establish surveyed accuracy.
+
+## Data and metadata mapping
+
+| Input | Output |
+| --- | --- |
+| Indexed part geometry and linear RGB | Shared-asset GLBs with unlit, double-sided materials |
+| Visible instance placement/rotation | One leaf tile per instance; same asset content reused |
+| Asset ID/name and source digest | glTF EXT_mesh_features + EXT_structural_metadata property table |
+| Instance ID/name, asset ID, source kind/digest | 3D Tiles tile metadata; inherited when geometry is picked |
+| Project identity/revision, cloud binding, source normalization offset, part IDs | Allowlisted provenance.json sidecar |
+| Input file byte digest and checkout revision | Export report and provenance; revision is null outside Git |
+| Hidden geometry, animation, hierarchy grouping, BOM/compiler findings, source documents, room decoration | Explicitly excluded; no claim of lossless IR transfer |
+
+There is no static feature ID per animated component: all primitives of a shared
+asset refer to its single asset feature. Part identities are preserved in node
+extras and the sidecar. Instance identity belongs to the leaf tile and remains
+distinct when two instances share one GLB. Arbitrary provider settings, raw IR,
+source documents and credentials are not copied; this allowlist is stricter than
+the full OI portable export. It cannot detect secrets pasted into an allowed name.
+
+## Validation and evidence
+
+The converter writes tileset.json, content-addressed GLBs, provenance.json and
+export-report.json with source/output hashes, Python version, payload size and
+conversion timing. Existing unrelated files in the output directory are not
+deleted; the report and validators enumerate only current referenced content.
+Use a fresh output directory for a distributable package.
+
+`npm run validate` records complete diagnostics from 3d-tiles-validator 0.6.1
+and gltf-validator 2.0.0-dev.3.10. The latter reports metadata extensions as
+unsupported informational messages; the 3D Tiles validator additionally checks
+those extensions. Zero core errors alone is not proof that every extension or
+engineering property is valid.
+
+`npm run test:browser` starts and closes its own Vite server, verifies placement
+against independent Cesium WGS84/ENU and Three.js Euler implementations within
+1 cm, loads both runtimes, and clicks pipette geometry to check exact identity.
+It saves screenshots, browser/runtime versions, load timing, and memory metrics
+under evidence/. External browser requests are blocked in this test.
+
+The workflow runs Python checks on Linux/Windows and viewer/conformance checks
+at two demonstration anchors on Linux. Screenshots, validator diagnostics,
+checksums, geometry, and timing are uploaded as CI artifacts. Load/capture timing
+on a software-rendered browser is not interactive FPS or physical performance.
+
+The upstream FIELD-LAB merge has passing [benchmark](https://github.com/Mapped-Assembly/Open-Industries/actions/runs/37550844141),
+[scene](https://github.com/Mapped-Assembly/Open-Industries/actions/runs/37550844134),
+and [runtime](https://github.com/Mapped-Assembly/Open-Industries/actions/runs/37550844184)
+workflows at e88f5ce5f8eeb4eda6a49757d5325699cd815cea.
+Adapter CI is separate and must be checked at the published PR head.
+
+## Openness and limits
+
+The new source/documents in **this tools/geospatial directory** are MIT licensed.
+That license does not relicense the repository, imported FIELD-LAB or cleanroom
+assets, dependencies, or generated models. `--license-note` records the user's
+evidence or unresolved status; it does not grant permission or certify rights.
+Confirm original asset permissions before redistributing a grant demonstration.
+
+For a fully MIT-licensed interchange fixture, use
+`fixtures/open-equipment.oi.json`: two instances of a newly authored asymmetric
+workbench envelope, including a 90-degree rotation and shared geometry. Its
+conceptual boxes do not reuse the existing lab/CAD assets. Substitute that input
+in the converter command and set `--license-note="MIT; tools/geospatial/LICENSE"`.
+The browser smoke test specifically targets the 21-instance FIELD-LAB fixture;
+the minimal fixture can be inspected manually and checked with the validators.
+
+This first version exports the **static base layout**, not frame zero of the
+authored animation. No animation, scientific validity, perception, provider
+generation, cold-chain solver, live operation, or physical validation is implied.
+The small FIELD-LAB fixture is not a scalability benchmark. A state/replay
+overlay and resolved asset licensing remain follow-on work; issue #18 should
+stay open until its remaining evidence gates are addressed.

open_industries-0.1.0/tools/geospatial/export_scene.py

@@ -0,0 +1,417 @@
+"""Export bounded, static OI scenes as georeferenced 3D Tiles 1.1.
+
+Only Python's standard library is required. This is a small indexed-mesh GLB
+adapter, not a CAD tessellator or scalable tiling engine. Existing OI geometry
+is already normalized; originOffset is provenance, not a second translation.
+"""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import math
+import struct
+import subprocess
+import sys
+import time
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+Json = dict[str, Any]
+Vec3 = tuple[float, float, float]
+Matrix = list[list[float]]
+MAX_BYTES = 75 * 1024 * 1024
+C: Matrix = [[1, 0, 0, 0], [0, 0, -1, 0], [0, 1, 0, 0], [0, 0, 0, 1]]
+CI: Matrix = [[1, 0, 0, 0], [0, 0, 1, 0], [0, -1, 0, 0], [0, 0, 0, 1]]
+
+
+def identity() -> Matrix:
+    """Return a row-major identity matrix for internal computation."""
+    return [[float(i == j) for j in range(4)] for i in range(4)]
+
+
+def multiply(a: Matrix, b: Matrix) -> Matrix:
+    """Multiply row-major matrices; serialization is column-major."""
+    return [[sum(a[i][k] * b[k][j] for k in range(4)) for j in range(4)] for i in range(4)]
+
+
+def transform(matrix: Matrix, point: Vec3) -> Vec3:
+    """Transform a point with an affine matrix."""
+    return tuple(sum(matrix[i][j] * point[j] for j in range(3)) + matrix[i][3] for i in range(3))
+
+
+def columns(matrix: Matrix) -> list[float]:
+    """Serialize an internal matrix using the glTF/3D Tiles column convention."""
+    return [matrix[i][j] for j in range(4) for i in range(4)]
+
+
+def pose_matrix(position: Vec3, rotation: Vec3) -> Matrix:
+    """Match Three.js Euler XYZ in degrees: translation times Rx times Ry times Rz."""
+    x, y, z = (math.radians(v) for v in rotation)
+    rx = [[1, 0, 0, 0], [0, math.cos(x), -math.sin(x), 0], [0, math.sin(x), math.cos(x), 0], [0, 0, 0, 1]]
+    ry = [[math.cos(y), 0, math.sin(y), 0], [0, 1, 0, 0], [-math.sin(y), 0, math.cos(y), 0], [0, 0, 0, 1]]
+    rz = [[math.cos(z), -math.sin(z), 0, 0], [math.sin(z), math.cos(z), 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]]
+    result = multiply(multiply(rx, ry), rz)
+    for i in range(3):
+        result[i][3] = position[i]
+    return result
+
+
+def finite(value: Any, label: str) -> float:
+    """Require a finite numeric value without accepting booleans."""
+    if isinstance(value, bool) or not isinstance(value, (int, float)) or not math.isfinite(value):
+        raise ValueError(f"{label} must be a finite number")
+    return float(value)
+
+
+def vector(value: Any, label: str) -> Vec3:
+    """Validate a bounded three-component vector."""
+    if not isinstance(value, list) or len(value) != 3:
+        raise ValueError(f"{label} must have three components")
+    result = tuple(finite(v, label) for v in value)
+    if any(abs(v) > 1e6 for v in result):
+        raise ValueError(f"{label} exceeds the supported local coordinate range")
+    return result
+
+
+def text_id(value: Any, label: str) -> str:
+    """Require an identifier or name of bounded length."""
+    if not isinstance(value, str) or not 0 < len(value) <= 512:
+        raise ValueError(f"{label} must be a nonempty string of at most 512 characters")
+    return value
+
+
+@dataclass(frozen=True)
+class Anchor:
+    """WGS84 demonstration origin; heading is clockwise from true north."""
+
+    longitude: float
+    latitude: float
+    height: float
+    heading: float
+
+    def __post_init__(self) -> None:
+        """Reject invalid geographic anchors before generating artifacts."""
+        for key in ("longitude", "latitude", "height", "heading"):
+            finite(getattr(self, key), key)
+        if not -180 <= self.longitude <= 180 or not -90 <= self.latitude <= 90:
+            raise ValueError("longitude/latitude must be within WGS84 geographic bounds")
+        if not -1000 <= self.height <= 100000 or not 0 <= self.heading < 360:
+            raise ValueError("height must be -1000..100000 m and heading 0..<360 degrees")
+
+    def matrix(self) -> Matrix:
+        """Map heading-adjusted ENU to ECEF using the WGS84 ellipsoid."""
+        lon, lat, heading = map(math.radians, (self.longitude, self.latitude, self.heading))
+        a, e2 = 6378137.0, 6.6943799901413165e-3
+        n = a / math.sqrt(1 - e2 * math.sin(lat) ** 2)
+        origin = ((n + self.height) * math.cos(lat) * math.cos(lon),
+                  (n + self.height) * math.cos(lat) * math.sin(lon),
+                  (n * (1 - e2) + self.height) * math.sin(lat))
+        east = (-math.sin(lon), math.cos(lon), 0.0)
+        north = (-math.sin(lat) * math.cos(lon), -math.sin(lat) * math.sin(lon), math.cos(lat))
+        up = (math.cos(lat) * math.cos(lon), math.cos(lat) * math.sin(lon), math.sin(lat))
+        frame = identity()
+        for i in range(3):
+            frame[i][:3] = [east[i], north[i], up[i]]
+            frame[i][3] = origin[i]
+        rotation = identity()
+        rotation[0][:2] = [math.cos(heading), math.sin(heading)]
+        rotation[1][:2] = [-math.sin(heading), math.cos(heading)]
+        return multiply(frame, rotation)
+
+
+def write_json(path: Path, value: Any) -> None:
+    """Write deterministic UTF-8 JSON with no nonstandard numeric values."""
+    path.write_text(json.dumps(value, indent=2, ensure_ascii=False, allow_nan=False) + "\n", encoding="utf-8")
+
+
+def digest(data: bytes) -> str:
+    """Compute byte identity for input and output evidence."""
+    return hashlib.sha256(data).hexdigest()
+
+
+def bounds(points: list[Vec3]) -> list[float]:
+    """Create a 3D Tiles axis-aligned box from already Z-up points."""
+    if not points:
+        raise ValueError("No visible geometry to export")
+    lo = [min(p[i] for p in points) for i in range(3)]
+    hi = [max(p[i] for p in points) for i in range(3)]
+    half = [max((hi[i] - lo[i]) / 2, 1e-7) for i in range(3)]
+    return [(hi[i] + lo[i]) / 2 for i in range(3)] + [half[0], 0, 0, 0, half[1], 0, 0, 0, half[2]]
+
+
+def asset_points(asset: Json) -> list[Vec3]:
+    """Return normalized Y-up points without reapplying source originOffset."""
+    return [tuple(part["vertices"][i:i + 3]) for part in asset["parts"] for i in range(0, len(part["vertices"]), 3)]
+
+
+def validate_scene(scene: Json) -> tuple[dict[str, Json], dict[str, Json]]:
+    """Validate the supported static scene and exact source/version bindings.
+
+    Animation is reported as excluded, never sampled or presented as physics.
+    Missing geometry is rejected rather than replaced with an invented envelope.
+    """
+    if scene.get("format") != "astra.scene" or scene.get("version") != 1 or scene.get("units") != "m" or scene.get("upAxis") != "Y":
+        raise ValueError("Only astra.scene v1 with meters/Y-up is supported")
+    refs: dict[str, Json] = {}
+    assets: dict[str, Json] = {}
+    versions: dict[str, Json] = {}
+    for ref in scene.get("assets", []):
+        key = text_id(ref.get("id"), "asset.id")
+        if key in refs:
+            raise ValueError("Duplicate asset reference")
+        refs[key] = ref
+    for asset in scene.get("bundledAssets", []):
+        key = text_id(asset.get("id"), "bundled asset.id")
+        if key in assets:
+            raise ValueError("Duplicate bundled asset")
+        assets[key] = asset
+    for entry in scene.get("bundledVersions", []):
+        key = text_id(entry.get("cloudVersionId"), "cloudVersionId")
+        if key in versions:
+            raise ValueError("Duplicate cloud version")
+        versions[key] = entry["asset"]
+    instances = scene.get("instances")
+    if not isinstance(instances, list) or not 1 <= len(instances) <= 1000:
+        raise ValueError("A scene must have 1..1000 instances")
+    ids: set[str] = set()
+    bound: dict[str, Json] = {}
+    for instance in instances:
+        key = text_id(instance.get("id"), "instance.id")
+        text_id(instance.get("name"), "instance.name")
+        if key in ids:
+            raise ValueError("Duplicate instance ID")
+        ids.add(key)
+        vector(instance.get("position"), "position")
+        vector(instance.get("rotation"), "rotation")
+        if not isinstance(instance.get("visible"), bool):
+            raise ValueError("visible must be boolean")
+        asset_id = instance.get("assetId")
+        asset = versions.get(instance["cloudVersionId"]) if "cloudVersionId" in instance else assets.get(asset_id)
+        ref = refs.get(asset_id)
+        if not asset or not ref or asset.get("id") != asset_id:
+            raise ValueError(f"Missing exact geometry binding for {key}")
+        text_id(asset.get("name"), "asset.name")
+        if asset.get("units") != "m" or asset.get("upAxis") != "Y" or asset.get("schemaVersion") != 1:
+            raise ValueError("Asset must use schemaVersion 1, meters/Y-up")
+        source = asset.get("source", {})
+        if source.get("kind") not in ("form", "step", "generated"):
+            raise ValueError("Invalid source kind")
+        text_id(source.get("filename"), "source filename")
+        text_id(source.get("digest"), "source digest")
+        for field in ("kind", "digest", "version", "projectId"):
+            if source.get(field) != ref.get("source", {}).get(field):
+                raise ValueError(f"Source revision mismatch: {key}/{field}")
+        project = asset.get("formProject") or {}
+        if ref.get("projectRevision") is not None and ref["projectRevision"] != project.get("revision"):
+            raise ValueError("Source project revision mismatch")
+        if source.get("projectId") is not None and project.get("projectId") not in (None, source["projectId"]):
+            raise ValueError("Source project ID mismatch")
+        vector(asset.get("originOffset"), "originOffset")
+        parts = asset.get("parts")
+        if not isinstance(parts, list) or not parts:
+            raise ValueError("Asset has no mesh parts")
+        part_ids: set[str] = set()
+        total = 0
+        for part in parts:
+            part_id = text_id(part.get("id"), "part.id")
+            text_id(part.get("name"), "part.name")
+            if part_id in part_ids:
+                raise ValueError("Duplicate part ID")
+            part_ids.add(part_id)
+            vertices, indices = part.get("vertices"), part.get("indices")
+            if not isinstance(vertices, list) or len(vertices) < 9 or len(vertices) % 3:
+                raise ValueError("Invalid mesh vertices")
+            for v in vertices:
+                if abs(finite(v, "vertex")) > 1e6:
+                    raise ValueError("Vertex exceeds local range")
+            total += len(vertices) // 3
+            if total > 2_000_000:
+                raise ValueError("Asset exceeds 2 million vertices")
+            if not isinstance(indices, list) or not indices or len(indices) % 3 or any(type(i) is not int or not 0 <= i < len(vertices) // 3 for i in indices):
+                raise ValueError("Invalid triangle indices")
+            color = vector(part.get("color", [0.7, 0.8, 0.75]), "part color")
+            if any(not 0 <= c <= 1 for c in color):
+                raise ValueError("Color must be linear RGB within 0..1")
+        bound[key] = asset
+    return bound, refs
+
+
+class Glb:
+    """Encode existing indexed OI meshes and bounded asset feature metadata."""
+
+    def __init__(self) -> None:
+        """Initialize aligned binary storage and a glTF 2.0 document."""
+        self.binary = bytearray()
+        self.doc: Json = {"asset": {"version": "2.0", "generator": "OI static geospatial adapter v1"},
+                          "scene": 0, "scenes": [{"nodes": []}], "nodes": [], "meshes": [],
+                          "materials": [], "accessors": [], "bufferViews": [],
+                          "extensionsUsed": ["KHR_materials_unlit", "EXT_mesh_features", "EXT_structural_metadata"]}
+
+    def view(self, data: bytes, target: int | None = None) -> int:
+        """Append one four-byte-aligned glTF buffer view."""
+        self.binary.extend(b"\0" * ((-len(self.binary)) % 4))
+        item: Json = {"buffer": 0, "byteOffset": len(self.binary), "byteLength": len(data)}
+        if target is not None:
+            item["target"] = target
+        self.binary.extend(data)
+        self.doc["bufferViews"].append(item)
+        return len(self.doc["bufferViews"]) - 1
+
+    def accessor(self, values: list[Any], component: int, kind: str, target: int) -> int:
+        """Encode validated positions or triangle indices as a glTF accessor."""
+        data = struct.pack("<" + ("f" if component == 5126 else "I") * len(values), *values)
+        count = len(values) // (3 if kind == "VEC3" else 1)
+        item: Json = {"bufferView": self.view(data, target), "componentType": component, "count": count, "type": kind}
+        if kind == "VEC3":
+            item["min"] = [min(values[i::3]) for i in range(3)]
+            item["max"] = [max(values[i::3]) for i in range(3)]
+        self.doc["accessors"].append(item)
+        return len(self.doc["accessors"]) - 1
+
+    def encode(self, asset: Json) -> bytes:
+        """Serialize a shared-asset GLB with explicit feature ID zero per vertex."""
+        properties: Json = {}
+        feature = {"assetId": asset["id"], "assetName": asset["name"], "sourceDigest": asset["source"]["digest"]}
+        for key, value in feature.items():
+            raw = value.encode("utf-8")
+            properties[key] = {"values": self.view(raw), "stringOffsets": self.view(struct.pack("<II", 0, len(raw))), "stringOffsetType": "UINT32"}
+        self.doc["extensions"] = {"EXT_structural_metadata": {
+            "schema": {"id": "oi_asset_v1", "classes": {"equipment": {"properties": {key: {"type": "STRING"} for key in feature}}}},
+            "propertyTables": [{"class": "equipment", "count": 1, "properties": properties}]}}
+        for part in asset["parts"]:
+            material = len(self.doc["materials"])
+            self.doc["materials"].append({"pbrMetallicRoughness": {"baseColorFactor": part.get("color", [0.7, 0.8, 0.75]) + [1]},
+                                          "doubleSided": True, "extensions": {"KHR_materials_unlit": {}}})
+            primitive = {"attributes": {"POSITION": self.accessor(part["vertices"], 5126, "VEC3", 34962),
+                                         "_FEATURE_ID_0": self.accessor([0.0] * (len(part["vertices"]) // 3), 5126, "SCALAR", 34962)},
+                         "indices": self.accessor(part["indices"], 5125, "SCALAR", 34963), "material": material,
+                         "extensions": {"EXT_mesh_features": {"featureIds": [{"featureCount": 1, "attribute": 0, "propertyTable": 0}]}}}
+            mesh = len(self.doc["meshes"])
+            self.doc["meshes"].append({"name": part["name"], "primitives": [primitive]})
+            self.doc["scenes"][0]["nodes"].append(len(self.doc["nodes"]))
+            self.doc["nodes"].append({"mesh": mesh, "name": part["name"], "extras": {"partId": part["id"]}})
+        self.doc["buffers"] = [{"byteLength": len(self.binary)}]
+        raw_json = json.dumps(self.doc, separators=(",", ":"), ensure_ascii=False).encode("utf-8")
+        raw_json += b" " * ((-len(raw_json)) % 4)
+        raw_bin = bytes(self.binary) + b"\0" * ((-len(self.binary)) % 4)
+        length = 12 + 8 + len(raw_json) + 8 + len(raw_bin)
+        return struct.pack("<III", 0x46546C67, 2, length) + struct.pack("<II", len(raw_json), 0x4E4F534A) + raw_json + struct.pack("<II", len(raw_bin), 0x004E4942) + raw_bin
+
+
+def source_revision(path: Path) -> str | None:
+    """Return the checkout revision if available; never invent an attribution."""
+    try:
+        return subprocess.check_output(["git", "rev-parse", "HEAD"], cwd=path.parent, text=True, stderr=subprocess.DEVNULL).strip()
+    except (OSError, subprocess.CalledProcessError):
+        return None
+
+
+def export_scene(source_path: Path, output: Path, anchor: Anchor, license_note: str) -> Json:
+    """Export validated static geometry and an allowlisted provenance sidecar.
+
+    Only selected source fields are copied; arbitrary Form source documents,
+    provider configuration and credentials are never copied to outputs.
+    """
+    started = time.perf_counter()
+    raw = source_path.read_bytes()
+    if len(raw) > MAX_BYTES:
+        raise ValueError("Scene exceeds the 75 MiB supported input limit")
+    scene = json.loads(raw)
+    bound, refs = validate_scene(scene)
+    output.mkdir(parents=True, exist_ok=True)
+    geometry = output / "geometry"
+    geometry.mkdir(exist_ok=True)
+    emitted: dict[str, str] = {}
+    children: list[Json] = []
+    instances: list[Json] = []
+    all_points: list[Vec3] = []
+    hidden: list[str] = []
+    for instance in scene["instances"]:
+        if not instance["visible"]:
+            hidden.append(instance["id"])
+            continue
+        asset = bound[instance["id"]]
+        # Exact geometry/provenance content identity permits shared immutable GLBs.
+        encoded = Glb().encode(asset)
+        content_hash = digest(encoded)
+        filename = f"geometry/{content_hash}.glb"
+        if content_hash not in emitted:
+            (output / filename).write_bytes(encoded)
+            emitted[content_hash] = filename
+        pose = pose_matrix(vector(instance["position"], "position"), vector(instance["rotation"], "rotation"))
+        # Content is GLB Y-up; runtimes apply C. Tile transforms are already Z-up.
+        tile_pose = multiply(multiply(C, pose), CI)
+        points = asset_points(asset)
+        all_points.extend(transform(multiply(C, pose), p) for p in points)
+        project = asset.get("formProject") or {}
+        metadata = {"instanceId": instance["id"], "assetId": asset["id"], "name": instance["name"],
+                    "sourceKind": asset["source"]["kind"], "sourceDigest": asset["source"]["digest"]}
+        children.append({"boundingVolume": {"box": bounds([transform(C, p) for p in points])},
+                         "transform": columns(tile_pose), "geometricError": 0,
+                         "content": {"uri": filename}, "metadata": {"class": "equipment", "properties": metadata}})
+        instances.append({**metadata, "contentUri": filename, "sourceFilename": asset["source"]["filename"],
+                          "sourceVersion": asset["source"].get("version"),
+                          "projectId": project.get("projectId", asset["source"].get("projectId")),
+                          "projectRevision": project.get("revision", refs[asset["id"]].get("projectRevision")),
+                          "cloudVersionId": instance.get("cloudVersionId"),
+                          "sourceNormalizationOffset": asset["originOffset"],
+                          "position": instance["position"], "rotationDegreesXYZ": instance["rotation"],
+                          "partIds": [part["id"] for part in asset["parts"]]})
+    root_box = bounds(all_points)
+    schema = {"id": "oi_scene_v1", "classes": {"equipment": {"properties": {
+        key: {"type": "STRING"} for key in ("instanceId", "assetId", "name", "sourceKind", "sourceDigest")}}}}
+    # A nonzero empty-root error requests refinement to exact leaf content.
+    root_error = max(root_box[3], root_box[7], root_box[11]) * 2
+    tileset = {"asset": {"version": "1.1"}, "geometricError": root_error, "schema": schema,
+               "root": {"boundingVolume": {"box": root_box}, "transform": columns(anchor.matrix()),
+                        "geometricError": root_error, "refine": "ADD", "children": children},
+               "extras": {"provenanceUri": "provenance.json", "evidence": "conceptual-static-scene"}}
+    write_json(output / "tileset.json", tileset)
+    write_json(output / "provenance.json", {
+        "schema": "oi-geospatial-provenance/v1", "sourceSha256": digest(raw),
+        "sourceRevision": source_revision(source_path), "sourceFilename": source_path.name,
+        "anchor": vars(anchor), "placement": "demonstration anchor; not surveyed or deployed",
+        "frame": "OI +X east, +Y up, -Z north at heading 0; clockwise heading from true north",
+        "normalization": "Stored vertices are normalized. Stored instance position already locates the normalized origin. originOffset is retained only as provenance.",
+        "licenseNote": license_note, "instances": instances,
+        "excluded": {"hiddenInstances": hidden, "animationTracks": len(scene.get("animation", {}).get("tracks", [])),
+                     "fields": ["BOM, compiler findings, arbitrary source documents", "room decoration, hierarchy grouping, textures, physics and animation"]},
+        "capabilities": {"staticGeometry": "passed", "georeferencedPlacement": "passed",
+                         "animation": "not-tested", "physicalValidation": "not-tested",
+                         "licensePermission": "not-tested", "viewerInteroperability": "not-tested"}})
+    files = sorted([output / "tileset.json", output / "provenance.json"] + [output / name for name in emitted.values()])
+    report = {"schema": "oi-geospatial-export/v1", "inputSha256": digest(raw),
+              "pythonVersion": sys.version, "instances": len(instances), "uniqueGlbs": len(emitted),
+              "verticesPerInstanceTotal": len(all_points), "rootBox": root_box,
+              "conversionSeconds": time.perf_counter() - started, "payloadBytes": sum(p.stat().st_size for p in files),
+              "checksums": {p.relative_to(output).as_posix(): digest(p.read_bytes()) for p in files},
+              "conformance": "not-tested; run npm run validate in tools/geospatial",
+              "limitations": ["static base layout; no timeline sampling", "one small site; no LOD simplification", "conceptual geometry; no engineering certification"]}
+    write_json(output / "export-report.json", report)
+    return report
+
+
+def main() -> int:
+    """Run the CLI with an explicit geographic anchor and provenance statement."""
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("scene", type=Path)
+    parser.add_argument("output", type=Path)
+    parser.add_argument("--longitude", required=True, type=float)
+    parser.add_argument("--latitude", required=True, type=float)
+    parser.add_argument("--height", required=True, type=float, help="WGS84 ellipsoidal height in meters; not terrain height")
+    parser.add_argument("--heading", required=True, type=float, help="Clockwise degrees from true north; 0 <= heading < 360")
+    parser.add_argument("--license-note", required=True, help="Source license/permission evidence or explicit unresolved status; not a permission grant")
+    args = parser.parse_args()
+    try:
+        result = export_scene(args.scene, args.output, Anchor(args.longitude, args.latitude, args.height, args.heading), args.license_note)
+    except (ValueError, KeyError, TypeError, OSError) as exc:
+        parser.exit(1, f"Export failed: {exc}\n")
+    print(json.dumps({"instances": result["instances"], "uniqueGlbs": result["uniqueGlbs"], "payloadBytes": result["payloadBytes"]}))
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

open_industries-0.1.0/tools/geospatial/open_industries.egg-info/PKG-INFO

@@ -0,0 +1,171 @@
+Metadata-Version: 2.4
+Name: open-industries
+Version: 0.1.0
+Summary: Static Open Industries scene exporter for georeferenced 3D Tiles
+Author: Mapped Assembly
+License: MIT License
+        
+        Copyright (c) 2026 Isayah Culbertson
+        
+        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.
+        
+Project-URL: Homepage, https://github.com/Mapped-Assembly/Open-Industries
+Project-URL: Repository, https://github.com/Mapped-Assembly/Open-Industries
+Project-URL: Issues, https://github.com/Mapped-Assembly/Open-Industries/issues
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+
+# Static OI scenes → 3D Tiles 1.1
+
+A small, independently runnable Python converter and local CesiumJS/Three.js
+interoperability demo for [issue #18](https://github.com/Mapped-Assembly/Open-Industries/issues/18).
+It consumes the geometry already bundled in a portable OI scene. It does not
+tessellate CAD, perform physics, or build a general-purpose streaming hierarchy.
+
+## Reproduce
+
+Python 3.11+ is sufficient for conversion and contract tests. The separate
+viewer/validator package uses Node 22.18+ and a committed npm lockfile. Root
+application dependencies and provider credentials are unnecessary.
+
+From the repository root:
+
+```sh
+python tools/geospatial/export_scene.py benchmarks/field-lab/fixtures/field-lab.oi.json tools/geospatial/public/export --longitude=-73.977 --latitude=40.684 --height=30 --heading=0 --license-note="Existing conceptual FIELD-LAB fixture; redistribution permission unresolved"
+python -m unittest discover -s tools/geospatial -p test_export.py -v
+cd tools/geospatial
+npm ci --ignore-scripts
+npx playwright install chromium
+npm run validate
+npm run test:browser
+npm run serve
+```
+
+Open <http://127.0.0.1:4194/> for CesiumJS or
+<http://127.0.0.1:4194/?viewer=three> for the independent 3D Tiles renderer.
+The server is local; nothing is published or deployed. Both runtimes load the
+same local tileset without Cesium ion, imagery, login, or tokens. Dependencies
+and browsers need network access during installation only.
+
+`--ignore-scripts` avoids unused native SQLite build hooks pulled in by the
+validator's archive tooling. This adapter validates directory-based JSON/GLB,
+not SQLite tile archives. The pinned sharp override supplies platform packages
+instead of the old validator dependency's legacy installation hook. Runtime
+dependencies retain their own licenses.
+
+## Coordinate contract
+
+- Input is `astra.scene` v1, meters, right-handed Y-up. OI rotations use
+  Three.js Euler XYZ in degrees.
+- At heading zero, OI +X is east, +Y is up, and -Z is north. The caller explicitly
+  supplies WGS84 longitude, latitude, **ellipsoidal** height, and heading.
+  Heading rotates clockwise from true north, in [0, 360).
+- GLB positions remain Y-up. A 3D Tiles runtime applies the standard Y-up→Z-up
+  rotation `C`, mapping (x,y,z) to (x,-z,y). Child transforms are
+  `C × OI_pose × inverse(C)`. The root is WGS84 ENU→ECEF with heading.
+  Tile bounds are Z-up; all serialized matrices are column-major.
+  The empty root uses a conservative extent-sized geometric error to request
+  refinement; exact leaf geometry has zero geometric error.
+- Stored mesh vertices are already normalized and stored instance positions
+  already locate those normalized origins. **Do not add originOffset again.**
+  The offset is retained as source provenance.
+- The Three.js viewer recenters the ECEF scene into the original local meter
+  frame for numerical precision. It loads the identical geographic tileset.
+- Geographic anchors are illustrative. The converter does not fetch terrain,
+  infer ground height, geocode a lab, or establish surveyed accuracy.
+
+## Data and metadata mapping
+
+| Input | Output |
+| --- | --- |
+| Indexed part geometry and linear RGB | Shared-asset GLBs with unlit, double-sided materials |
+| Visible instance placement/rotation | One leaf tile per instance; same asset content reused |
+| Asset ID/name and source digest | glTF EXT_mesh_features + EXT_structural_metadata property table |
+| Instance ID/name, asset ID, source kind/digest | 3D Tiles tile metadata; inherited when geometry is picked |
+| Project identity/revision, cloud binding, source normalization offset, part IDs | Allowlisted provenance.json sidecar |
+| Input file byte digest and checkout revision | Export report and provenance; revision is null outside Git |
+| Hidden geometry, animation, hierarchy grouping, BOM/compiler findings, source documents, room decoration | Explicitly excluded; no claim of lossless IR transfer |
+
+There is no static feature ID per animated component: all primitives of a shared
+asset refer to its single asset feature. Part identities are preserved in node
+extras and the sidecar. Instance identity belongs to the leaf tile and remains
+distinct when two instances share one GLB. Arbitrary provider settings, raw IR,
+source documents and credentials are not copied; this allowlist is stricter than
+the full OI portable export. It cannot detect secrets pasted into an allowed name.
+
+## Validation and evidence
+
+The converter writes tileset.json, content-addressed GLBs, provenance.json and
+export-report.json with source/output hashes, Python version, payload size and
+conversion timing. Existing unrelated files in the output directory are not
+deleted; the report and validators enumerate only current referenced content.
+Use a fresh output directory for a distributable package.
+
+`npm run validate` records complete diagnostics from 3d-tiles-validator 0.6.1
+and gltf-validator 2.0.0-dev.3.10. The latter reports metadata extensions as
+unsupported informational messages; the 3D Tiles validator additionally checks
+those extensions. Zero core errors alone is not proof that every extension or
+engineering property is valid.
+
+`npm run test:browser` starts and closes its own Vite server, verifies placement
+against independent Cesium WGS84/ENU and Three.js Euler implementations within
+1 cm, loads both runtimes, and clicks pipette geometry to check exact identity.
+It saves screenshots, browser/runtime versions, load timing, and memory metrics
+under evidence/. External browser requests are blocked in this test.
+
+The workflow runs Python checks on Linux/Windows and viewer/conformance checks
+at two demonstration anchors on Linux. Screenshots, validator diagnostics,
+checksums, geometry, and timing are uploaded as CI artifacts. Load/capture timing
+on a software-rendered browser is not interactive FPS or physical performance.
+
+The upstream FIELD-LAB merge has passing [benchmark](https://github.com/Mapped-Assembly/Open-Industries/actions/runs/37550844141),
+[scene](https://github.com/Mapped-Assembly/Open-Industries/actions/runs/37550844134),
+and [runtime](https://github.com/Mapped-Assembly/Open-Industries/actions/runs/37550844184)
+workflows at e88f5ce5f8eeb4eda6a49757d5325699cd815cea.
+Adapter CI is separate and must be checked at the published PR head.
+
+## Openness and limits
+
+The new source/documents in **this tools/geospatial directory** are MIT licensed.
+That license does not relicense the repository, imported FIELD-LAB or cleanroom
+assets, dependencies, or generated models. `--license-note` records the user's
+evidence or unresolved status; it does not grant permission or certify rights.
+Confirm original asset permissions before redistributing a grant demonstration.
+
+For a fully MIT-licensed interchange fixture, use
+`fixtures/open-equipment.oi.json`: two instances of a newly authored asymmetric
+workbench envelope, including a 90-degree rotation and shared geometry. Its
+conceptual boxes do not reuse the existing lab/CAD assets. Substitute that input
+in the converter command and set `--license-note="MIT; tools/geospatial/LICENSE"`.
+The browser smoke test specifically targets the 21-instance FIELD-LAB fixture;
+the minimal fixture can be inspected manually and checked with the validators.
+
+This first version exports the **static base layout**, not frame zero of the
+authored animation. No animation, scientific validity, perception, provider
+generation, cold-chain solver, live operation, or physical validation is implied.
+The small FIELD-LAB fixture is not a scalability benchmark. A state/replay
+overlay and resolved asset licensing remain follow-on work; issue #18 should
+stay open until its remaining evidence gates are addressed.

open_industries-0.1.0/tools/geospatial/open_industries.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+README.md
+pyproject.toml
+tools/geospatial/LICENSE
+tools/geospatial/README.md
+tools/geospatial/export_scene.py
+tools/geospatial/open_industries.egg-info/PKG-INFO
+tools/geospatial/open_industries.egg-info/SOURCES.txt
+tools/geospatial/open_industries.egg-info/dependency_links.txt
+tools/geospatial/open_industries.egg-info/entry_points.txt
+tools/geospatial/open_industries.egg-info/top_level.txt

open_industries-0.1.0/tools/geospatial/open_industries.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

open_industries-0.1.0/tools/geospatial/open_industries.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+oi-export-scene = export_scene:main

open_industries-0.1.0/tools/geospatial/open_industries.egg-info/top_level.txt

@@ -0,0 +1 @@
+export_scene