Skip to content

Open-source platform for 3D AI agents. Turn text or a photo into a rigged, animated GLB avatar, give it an LLM brain, memory and a wallet, and embed it anywhere with one web component. Remote MCP server, x402 payments, Three.js, browser-native.

docs(provenance): document automatic-by-default credentialing in the spec, guide, and changelog

nirholas3965c85ff681
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 4d5dad88a..c040e3148 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -15,6 +15,7 @@ Public history for [three.ws](https://three.ws), newest first. New pages come fr
- **<agent-3d> gets model-viewer's AR contract: ar-modes, variants, hotspots, and /ar drops the third-party CDN**: <agent-3d> now matches the AR/viewer contract the market expects from model-viewer (Apache-2.0): ar-modes picks which launch paths to try (WebXR, Scene Viewer, Quick Look), ar-placement anchors floor or wall, ios-src supplies a pre-baked USDZ or the element generates a best-effort one on device, variant-name switches a GLB's real KHR_materials_variants materials live, and any element with slot="hotspot" tracks a 3D position and flies the camera to a saved orbit on click. /avatars/:id/ar and /agents/:id/ar (pages/ar.html) now run entirely on <agent-3d ar>; the page no longer loads a third-party viewer from a CDN. (`/avatars`) `[feature]`
- **Animation Studio: trim, loop-blend, and save any generated clip to your library**: The Animation Studio's prompt-to-clip flow (type a prompt, generate motion on the self-hosted GPU worker, preview it retargeted onto the loaded avatar) now has an editing and persistence half. The transport grows trim start/end inputs, a loop-blend duration field, and a loop toggle, all recomputed through a non-destructive edit path so the live preview, the GLB export, and the saved clip always agree on the current edit. A Save to library button collects a name and visibility and posts the canonical, pre-retarget clip to the shared clip library, so it plays back correctly on any future rig, not just the avatar it was previewed on. A separate bug that crashed every generated clip's playback the moment it reached the browser (AnimationClip.parse() expected userData as a JSON string, the server was sending an object) is also fixed. (`/pose`) `[feature, fix]`
- **Engine QA: a free real-time-engine fitness grade, plus real LOD chains**: A new free grade answers the question a game engine's import step asks that neither glTF validation nor simulation readiness does: draw calls, material count, texel density against the mesh's real-world size, a per-level triangle budget for a LOD chain, and whether the mesh is cheap and closed enough to use as its own physics collider. GET/POST /api/3d/engine-qa grades any public GLB (format=stl exports a watertight mesh for printing); the same browser-only checks run with zero network cost in Rig Doctor, and the full grade with a one-click upgrade in the GLB viewer, through a shared <engine-qa> panel component. The underlying LOD builder (packages/glb-tools's buildLodChain, real meshoptimizer decimation tagged with MSFT_lod) is now also available on generation: send { "lods": true } to POST /api/forge and the finished creation gets a combined LOD-chain variant alongside its delivered mesh, the same opt-in, fire-and-forget pattern as the existing web-delivery variant. (`/docs/engine-qa`) `[feature]`
+- **Every generated and purchased model now ships with a signed provenance credential, free, by default**: Content credentials (specs/PROVENANCE_3D.md) used to be an on-demand, Claude-track action: you had to call anchor_provenance to get one. Now every GLB the Forge produces, across every generation lane (free NIM, Forge Pro, rigged avatars, self-host TRELLIS/Hunyuan, async GCP workers), gets an ed25519-signed content credential the moment it's materialized, and every first download of a paid asset from the x402 asset bazaar gets one too, with the hash and a verify link returned right in the download response. Signing and storage are free and local, no Solana write and no spend, so there's nothing to gate; the separate paid anchor_provenance upgrade, which additionally commits the hash on-chain, is untouched and still available. A credential is keyed by content hash, so it's issued exactly once per file no matter how many times a lane or endpoint touches it. Model pages now show the same verified / tampered / unverified badge the 3D viewer already had, and a third party can check any model for free with GET /api/provenance. The owner can turn automatic issuance off platform-wide with PROVENANCE_AUTO_DISABLE=true; nothing else about verification changes if they do. (`/docs/provenance`) `[feature, security]`
- **Real VRM avatars: spring bones, expressions, and .vrma clips via @pixiv/three-vrm**: The hand-rolled VRM loader is gone. vrm-boot.js now registers the real VRMLoaderPlugin (@pixiv/three-vrm) on the three.ws GLTFLoader, so VRM 0.x and 1.0 avatars get genuine MToon materials, spring-bone physics, node constraints, look-at, and all 18 expression presets, driven live by vrm.update(delta) in AnimationManager and mapped onto the ARKit-52 face-capture driver. VRMAnimationLoaderPlugin loads .vrma clips into the same retargeting pipeline that drives non-VRM humanoids, so a single clip plays on either. The Ready Player Me import page (/import-rpm) now accepts .vrm files alongside .glb, and a long-standing bug that 400'd every import at the final save step (it sent an invalid source value) is fixed. docs/avatar-engines.md upgrades three-vrm from interop to live. (`/docs/avatar-engines`) `[feature, fix]`
- **Restyle and part edits now prove they kept the rig, not just claim it**: Material Studio's AI restyle and seeded colorway variants, plus Restyle Studio's HoloPart "Regenerate part" tool, are now checked against their own source bytes with @three-ws/glb-diff before anything is persisted: a restyle declares it keeps topology, UVs, skeleton, skin, and clips, a part regenerate declares the narrower skeleton-and-clips promise since the part's own shape is meant to change, and the operation throws instead of returning a URL if the real diff shows otherwise. A successful restyle response now carries preserve: { kinds, verified: true } as evidence. Model Diff's underlying engine (packages/glb-diff) grew three independent mesh sub-hashes, topology, uv, and skinWeights, so a caller can tell which kind of change happened instead of one opaque geometry hash, and every lineage step in Restyle Studio that has a parent now shows a "Diff" link that opens Model Diff pre-loaded with that exact before/after pair. Regenerating a part also now mints its own durable lineage version automatically, closing a gap where part edits were not recorded. (`/restyle`) `[feature, improvement]`
- **Text-to-motion gets a second GPU backend: MoMask, selectable per request**: The self-hosted text-to-motion worker behind the Animation Studio and POST /api/forge-motion now runs two independent generation backends on the same GPU lane: MDM (Motion Diffusion Model, MIT), the existing default, and MoMask (EricGuo5513/momask-codes, MIT), a residual-VQ tokenizer plus masked and residual transformer that publishes a lower HumanML3D FID (0.045 vs. T2M-GPT's 0.141). Pass model: "momask" to /infer or /api/forge-motion to route a prompt through it instead; omit it and MDM keeps answering as before. Both backends converge on the same (T,22,3) HumanML3D position format and the same shared decode math, so a MoMask clip previews, retargets, and exports exactly like an MDM one. The two projects ship conflicting top-level `utils` packages; the worker resolves that at load time so either backend can be warmed in the same container without the other's modules leaking in. MoMask's checkpoints are staged to production storage and the worker is wired to load them; the first on-GPU deploy and a real in-house benchmark against MDM are tracked as the next step. (`/pose`) `[feature, infra]`
diff --git a/STRUCTURE.md b/STRUCTURE.md
index 093a62631..bd2776077 100644
--- a/STRUCTURE.md
+++ b/STRUCTURE.md
@@ -151,7 +151,7 @@ bottom.
| Portal (any website as a walkable world) | Page [pages/portal.html](pages/portal.html) `→ /portal` + controller [src/portal/main.js](src/portal/main.js), renderer [src/portal/render.js](src/portal/render.js), styles [src/portal/portal.css](src/portal/portal.css); reader [api/_lib/portal/outline.js](api/_lib/portal/outline.js) + guarded fetch [api/_lib/portal/fetch-site.js](api/_lib/portal/fetch-site.js) + robots matcher [api/_lib/portal/robots.js](api/_lib/portal/robots.js); pure layout [packages/portal/src/layout.js](packages/portal/src/layout.js); GLB export [api/_lib/portal/world-glb.js](api/_lib/portal/world-glb.js); endpoint [api/portal.js](api/portal.js) `→ /api/portal` | Live | Paste an address and walk the page: each section becomes a building sized by its word count (log scale), each link a door (same-site doors rebuild the world there and push browser history, outside links open the page), each image a billboard loaded through `/api/img`, each code block a monolith, and the palette comes from the page's own `theme-color` or a hash of its host. The layout is a pure, seeded function so the browser, the GLB exporter, the MCP tools and the npm package all build the identical city from one link. Crawler manners are part of the product: a declared user agent, `robots.txt` honoured per RFC 9309, one fetch per page cached fleet-wide for an hour, and an IP-pinned SSRF guard with size and time ceilings. `format=glb` returns the world as glTF with named nodes. SDK + CLI + MCP server: [packages/portal/](packages/portal). Docs: [docs/portal.md](docs/portal.md). Spec: [specs/PORTAL_WORLD.md](specs/PORTAL_WORLD.md). Tests: [tests/portal-robots.test.js](tests/portal-robots.test.js), [tests/portal-outline.test.js](tests/portal-outline.test.js), [tests/portal-layout.test.js](tests/portal-layout.test.js), [tests/portal-endpoint.test.js](tests/portal-endpoint.test.js), [tests/e2e/portal.spec.js](tests/e2e/portal.spec.js) |
| IRL (agents in the real world) | [pages/irl.html](pages/irl.html) `→ /irl` + [src/irl.js](src/irl.js), WebXR placement [src/ar/webxr.js](src/ar/webxr.js) + pinch [src/ar/pinch-scale.js](src/ar/pinch-scale.js), animated Quick Look bake [src/usdz-animated.js](src/usdz-animated.js) (static fallback [src/usdz-pipeline.js](src/usdz-pipeline.js)), backend [api/irl/](api/irl) | Live | Pin an agent at a real GPS spot; discovery is presence-proof-gated ([docs/irl/THREAT-MODEL.md](docs/irl/THREAT-MODEL.md)). **Place in AR** leads the dock on AR-capable devices: WebXR hit-test anchoring on Android with two-finger pinch resize (25%..400%) persisted to the pin (`anchor_scale`; the pinch lands as a follow-up `PATCH /api/irl/pins {id, scale}` after the placement tap), and ARKit Quick Look on iOS with the idle clip baked into the USDZ so the agent moves instead of standing in a T-pose. Discovered pins are equally alive in the in-page camera view: every mounted humanoid GLB plays the retargeted idle clip via a per-pin mixer ([src/irl/pin-idle.js](src/irl/pin-idle.js), phase-randomized, LOD-bounded), camera-aware gaze composes on top of the running animation, and the scene renders with ACES tone mapping + IBL + soft shadows (e2e: [tests/e2e/irl-pin-idle.spec.js](tests/e2e/irl-pin-idle.spec.js)). Inbound `/irl?avatar=<glb>` is the living-agent handoff from `GET /api/ar?…&kind=avatar` (explicit `?avatar=` wins over a saved session). Money Drops and World Lines: [docs/irl.md](docs/irl.md). SDK: [packages/irl/](packages/irl). **Share** ([src/irl/share-frame.js](src/irl/share-frame.js), [api/irl/share.js](api/irl/share.js), [api/irl/share/[token].js](api/irl/share/%5Btoken%5D.js)) mints a permanent, unfurlable `/irl/s/:token` link from the captured AR photo for the pin you just placed - never a coordinate, owner-gated, falls back to the plain native share sheet with no active pin. **Analytics** ([api/_lib/irl-analytics.js](api/_lib/irl-analytics.js), [api/irl/analytics.js](api/irl/analytics.js)) is the first site-wide usage rollup for the feature - pins placed, nearby reads, placement method, shares, drop claims - aged out by the existing hourly reaper. **Visit links and signs** ([src/irl/visit-link.js](src/irl/visit-link.js) pure rules, [src/irl/visit-banner.js](src/irl/visit-banner.js) the "you're here to meet" banner, printable sign [pages/irl-sign.html](pages/irl-sign.html) `→ /irl/sign?pin=<id>` + [src/irl-sign.js](src/irl-sign.js), dashboard modal in [src/dashboard-next/pages/irl-placements.js](src/dashboard-next/pages/irl-placements.js)): `/irl?pin=<id>` is the scannable handoff for a street demo. The page names the agent from the coordinate-free agent card until the presence-gated nearby read returns that pin, then flashes it and opens its card once. The discovered-pin card gains **View in AR** for ANY discovered pin, capability-routed by [src/irl/pin-ar.js](src/irl/pin-ar.js): iOS bakes the pin's GLB to an animated USDZ for Quick Look (the banner reads "Talk to <name>" and its tap reopens the card with the conversation live), Android with ARCore enters the same WebXR hit-test session as placement in a view-only mode (`enterFloorAnchor({ viewPin })`: the pin's mounted model is the session content, nothing persists, the group's transform is restored on exit), everything else opens the `/api/ar` launcher in a new tab. **Talk** ([src/irl/pin-talk.js](src/irl/pin-talk.js)) is a live spoken conversation with the agent standing in front of you, inside the pin sheet: the same `TalkController` as talk mode on `/avatars/:id` (mic or typed turn, `/api/chat` in the agent's persona by `agentId`, TTS in its voice, lipsync from the audio FFT onto the pin's mounted model via `AvatarMouthTarget`), barge-in on the mic, and a `talk` interaction logged once per conversation (never the transcript). While a conversation or a view-only AR session is open the pin's full model is pinned resident in `enforceLOD` (`_pinnedFull`). Runbook: [docs/irl/street-demo.md](docs/irl/street-demo.md). Tests: [tests/irl-visit-link.test.js](tests/irl-visit-link.test.js), [tests/irl-pin-ar.test.js](tests/irl-pin-ar.test.js), [tests/irl-pin-talk.test.js](tests/irl-pin-talk.test.js), e2e [tests/e2e/irl-pin-talk.spec.js](tests/e2e/irl-pin-talk.spec.js). |
| Smart glasses (the nearest-agent cue on your lens) | Pure HUD protocol [src/irl/glasses/protocol.js](src/irl/glasses/protocol.js), controller [src/irl/glasses/bridge.js](src/irl/glasses/bridge.js), Web Bluetooth transport [src/irl/glasses/transport.js](src/irl/glasses/transport.js), device adapters [src/irl/glasses/frame.js](src/irl/glasses/frame.js) (Brilliant Labs Frame) + [src/irl/glasses/g1.js](src/irl/glasses/g1.js) (Even Realities G1), connect sheet [src/irl/glasses/connect-ui.js](src/irl/glasses/connect-ui.js), wired into [src/irl.js](src/irl.js) behind the /irl "Connect glasses" button | Live (companion BLE lenses) · Meta Ray-Ban Display and native camera/voice lanes planned | No smart-glasses display in 2026 can render a three.ws avatar: Frame and the G1 are thin Bluetooth screens with no browser, and Meta Ray-Ban Display is a 600x600 additive panel whose SDK states custom pixel and 3D rendering are unsupported. So the lens carries the SIGNAL (nearest agent, direction, distance, arrivals) that /irl already computes for its on-screen nudge ([src/irl/proximity-cue.js](src/irl/proximity-cue.js)), and the phone keeps the BODY in AR. The protocol module is pure (no DOM, no Bluetooth, no clock) so formatting, direction glyphs and byte-level packet framing are unit tested; the bridge above it owns WHEN to push (3 Hz ceiling, single-flight writes, 4 s heartbeat that recovers a dropped write, 3.5 s announcements) and mirrors IrlNet's status-event shape. A connected link stamps its telemetry as a `glasses` encounter. Web Bluetooth is Chromium-only, and the connect sheet gates on that honestly rather than failing at pair time. Docs: [docs/glasses.md](docs/glasses.md) `→ /docs/glasses`, build plan [docs/glasses/meta-ray-ban-display.md](docs/glasses/meta-ray-ban-display.md), platform research [docs/glasses/research.md](docs/glasses/research.md). Tests: [tests/irl-glasses-protocol.test.js](tests/irl-glasses-protocol.test.js) |
-| Verifiable 3D provenance (content credentials) | Spec [specs/PROVENANCE_3D.md](specs/PROVENANCE_3D.md), pure core [api/_lib/provenance-3d.js](api/_lib/provenance-3d.js), Solana anchor [api/_lib/provenance-anchor.js](api/_lib/provenance-anchor.js), MCP tools [api/_mcp3d/tools/provenance.js](api/_mcp3d/tools/provenance.js) (`verify_provenance` free, `anchor_provenance` paid $0.05), free REST verify [api/provenance.js](api/provenance.js) `→ /api/provenance`, viewer badge [public/viewer.html](public/viewer.html), docs [docs/provenance.md](docs/provenance.md). | Live (verify) · anchor gated on issuer key + devnet funds | C2PA-style signed content credentials for AI 3D: creator, prompt, model/provider, lineage, timestamp, and the GLB's sha256, ed25519-signed by the three.ws issuer with the credential hash anchored on Solana. Free public `verify_provenance` / `GET /api/provenance?src=…` recompute the hash and return `verified | tampered | unknown` (a single changed byte → tampered); the verify path and response are coin-clean (both stores). `anchor_provenance` signs + writes the SPL Memo anchor + stores the credential in R2. Tests: [tests/provenance-3d.test.js](tests/provenance-3d.test.js). Evidence: [prompts/store-submissions/_generated/provenance/](prompts/store-submissions/_generated/provenance/). Store-submission prompt 19. |
+| Verifiable 3D provenance (content credentials, signed by default) | Spec [specs/PROVENANCE_3D.md](specs/PROVENANCE_3D.md), pure core [api/_lib/provenance-3d.js](api/_lib/provenance-3d.js), automatic issuance [api/_lib/auto-provenance.js](api/_lib/auto-provenance.js), Solana anchor [api/_lib/provenance-anchor.js](api/_lib/provenance-anchor.js), MCP tools [api/_mcp3d/tools/provenance.js](api/_mcp3d/tools/provenance.js) (`verify_provenance` free, `anchor_provenance` paid $0.05), free REST verify [api/provenance.js](api/provenance.js) `→ /api/provenance`, model page + viewer badge ([src/model-page.js](src/model-page.js), [public/viewer.html](public/viewer.html)), docs [docs/provenance.md](docs/provenance.md). | Live (verify + automatic signing) · anchor gated on issuer key + devnet funds | C2PA-style signed content credentials for AI 3D: creator, prompt, model/provider, lineage, timestamp, and the GLB's sha256, ed25519-signed by the three.ws issuer. Every forge-generated GLB (every lane: free NIM, Forge Pro, rigged avatars, self-host, async GCP workers) and every x402 paid-asset download gets this credential automatically and free, with no anchor and no spend, keyed by content hash so a credential is only ever issued once per file; the owner can turn it off with `PROVENANCE_AUTO_DISABLE=true`. Free public `verify_provenance` / `GET /api/provenance?src=…` recompute the hash and return `verified | tampered | unknown` (a single changed byte → tampered); the verify path and response are coin-clean (both stores). `anchor_provenance` remains a separate paid upgrade that additionally writes the SPL Memo anchor. Tests: [tests/provenance-3d.test.js](tests/provenance-3d.test.js), [tests/auto-provenance.test.js](tests/auto-provenance.test.js). Evidence: [prompts/store-submissions/_generated/provenance/](prompts/store-submissions/_generated/provenance/). Store-submission prompt 19, automatic-by-default prompt 079. |
| Simulation readiness (a physics grade for 3D assets) | Spec [specs/SIM_READINESS.md](specs/SIM_READINESS.md), pure core [api/_lib/sim-readiness.js](api/_lib/sim-readiness.js), storage [api/_lib/sim-readiness-store.js](api/_lib/sim-readiness-store.js) + migration [20260813180000_sim_readiness_grades.sql](api/_lib/migrations/20260813180000_sim_readiness_grades.sql), free MCP tool [api/_mcp3d/tools/sim-readiness.js](api/_mcp3d/tools/sim-readiness.js) (`grade_sim_readiness`), free REST [api/sim-readiness.js](api/sim-readiness.js) `→ /api/sim-readiness`, shared badge + details panel [public/sim-readiness-panel.js](public/sim-readiness-panel.js) (`<sim-readiness>`, used by [public/viewer.html](public/viewer.html) and [src/model-page.js](src/model-page.js)), write path in [api/_lib/forge-store.js](api/_lib/forge-store.js) `materializeCreation`, docs [docs/sim-readiness.md](docs/sim-readiness.md). | Live | The question a renderer never asks and a rigid-body solver always does: can this mesh be simulated as-is? Four verdicts (`simulation_ready`, `needs_scale`, `needs_repair`, `unusable`, plus `unreadable` for non-glTF bytes) over measurements derived entirely from the geometry: watertightness and winding via welded-position topology, real-world extents read as meters per the glTF unit convention, exact volume/centroid/inertia from the divergence theorem and tetrahedron covariance, and a convex-hull proxy with its convexity ratio. Nothing is guessed: where a value cannot be known from the mesh (true scale, density) the report says so. Grades are keyed by GLB content hash, not URL, so one row serves the forge creation, the Object Library entry, a remix and an arbitrary third-party URL; every finished generation is graded on the write path, so a model page renders its verdict with no extra request. Signed into the content credential as `simReadiness` (provenance v2), which is what makes the physics claim as forge-proof as the authorship claim. Free, no account, no coin surface, both stores. Tests: [tests/sim-readiness.test.js](tests/sim-readiness.test.js), [tests/api/sim-readiness-endpoint.test.js](tests/api/sim-readiness-endpoint.test.js), [tests/provenance-3d.test.js](tests/provenance-3d.test.js). |
| Engine QA (a real-time-engine fitness grade) | Isomorphic core [api/_lib/engine-qa-core.js](api/_lib/engine-qa-core.js) (thresholds + verdict math, zero imports), server grader [api/_lib/engine-qa.js](api/_lib/engine-qa.js), browser-only partial grader [src/engine-qa-client.js](src/engine-qa-client.js), free REST [api/3d/engine-qa.js](api/3d/engine-qa.js) `→ /api/3d/engine-qa` (`?lods=1` builds a real LOD chain first, `?format=stl` exports a watertight mesh), shared badge + details panel [public/engine-qa-panel.js](public/engine-qa-panel.js) (`<engine-qa>`, used by [public/viewer.html](public/viewer.html) and Rig Doctor's [src/rig-doctor-page.js](src/rig-doctor-page.js)), LOD chain builder [packages/glb-tools/src/lod.js](packages/glb-tools/src/lod.js) (`buildLodChain`, real meshoptimizer decimation tagged `MSFT_lod`), opt-in generation variant in [api/_lib/forge-store.js](api/_lib/forge-store.js) (`buildLodVariant`, wired through [api/_lib/forge-options.js](api/_lib/forge-options.js)'s `lods` option) + migration [20261015020000_forge_lod_variant.sql](api/_lib/migrations/20261015020000_forge_lod_variant.sql), docs [docs/engine-qa.md](docs/engine-qa.md) `→ /docs/engine-qa`. | Live | The question a game engine's import step asks that neither glTF validation nor [simulation readiness](docs/sim-readiness.md) answers: will this run at 60fps, and can it collide cheaply? Five checks, each `pass`/`warn`/`fail`/`skip`, overall the worst non-skip verdict: draw calls (real scene-graph walk, one per node+primitive pair actually reachable from the root, so instancing counts correctly), material count, texel density (texels per meter of real-world surface, `skip` honestly when nothing is UV-mapped to a texture), a per-LOD-level triangle budget plus the monotonic-decrease rule a chain must satisfy, and collider suitability (reuses the print pipeline's watertight/manifold analyzer). The thresholds and verdict math live in one zero-dependency core so the server grader and Rig Doctor's zero-network browser pass can never disagree. The same `buildLodChain` pipeline backs an on-demand upgrade in the panel and an opt-in `{ lods: true }` generation option that stores a combined `MSFT_lod` GLB as a third object alongside the delivered mesh, fire-and-forget, same pattern as the existing web-delivery variant. Tests: [tests/engine-qa-core.test.js](tests/engine-qa-core.test.js), [tests/engine-qa.test.js](tests/engine-qa.test.js), [tests/engine-qa-client.test.js](tests/engine-qa-client.test.js), [tests/forge-options.test.js](tests/forge-options.test.js), [tests/forge-store-materialize.test.js](tests/forge-store-materialize.test.js). |
| Engine bridges (Unity, Godot, Unreal) | Shared contract [specs/ENGINE_BRIDGE.md](specs/ENGINE_BRIDGE.md), Unity UPM package [packages/unity-bridge](packages/unity-bridge) (`ThreeWsClient.cs` + `ThreeWsForgeImporter.cs` on [glTFast](https://github.com/atteneder/glTFast)), Godot addon [packages/godot-bridge](packages/godot-bridge) (`three_ws_client.gd` + `forge_importer.gd` on Godot's native `GLTFDocument`), Unreal plugin [packages/unreal-bridge](packages/unreal-bridge) (`FThreeWsClient` + `FThreeWsForgeImporter` on Unreal's Interchange glTF pipeline), docs [docs/engine-bridges.md](docs/engine-bridges.md) `→ /docs/engine-bridges`. | Live (Unity, Godot) · Unreal plugin ships source-complete, untestable in this environment (no license-free headless Unreal install) | One prompt-to-mesh contract, three independent implementations, each calling only the public Forge API: `POST /api/forge` to submit, `GET /api/forge?job=<id>` to poll (server-side failover keeps the same job id even if the lane dies mid-run), a plain HTTPS GET to download. Anonymous by default via a per-instance `x-forge-client` handle, same free-first routing every other caller gets; set a provider key for BYOK. The same four shared import settings (`generate_colliders`, `import_materials`, `scale`, `destination`) map onto each engine's own equivalent: a convex `MeshCollider` in Unity, a `ConvexPolygonShape3D` in Godot, a bounding-box `UBodySetup` in Unreal. Each package ships an editor window/dock (Unity: `Window > three.ws > Forge Bridge`; Godot: the **three.ws Forge** dock; Unreal: `Window > three.ws Forge Bridge`) plus a runnable example and a README. Godot's `test/smoke_test.gd` runs the full flow headlessly against the live API (`godot --headless --script test/smoke_test.gd`); Unity and Unreal require a licensed GUI install to exercise, so they're verified by code review against the shared contract instead. |
diff --git a/data/changelog.json b/data/changelog.json
index fe91e2f77..0deeb0b99 100644
--- a/data/changelog.json
+++ b/data/changelog.json
@@ -1,6 +1,16 @@
{
"$comment": "Curated changelog entries for three.ws, the editorial layer of the public changelog. New PAGE launches are tracked automatically via the `added` field in data/pages.json; this file is for everything else holders care about: improvements, fixes, SDK releases, trading/payments capabilities, security work. scripts/build-page-index.mjs merges both sources into CHANGELOG.md, public/changelog.json, and public/changelog.xml. Newest first. Allowed tags: feature, improvement, fix, sdk, infra, docs, security, desktop (desktop entries become the desktop app's release notes). `link` is optional and must be a live three.ws path.",
"entries": [
+ {
+ "date": "2026-10-12",
+ "title": "Every generated and purchased model now ships with a signed provenance credential, free, by default",
+ "link": "/docs/provenance",
+ "summary": "Content credentials (specs/PROVENANCE_3D.md) used to be an on-demand, Claude-track action: you had to call anchor_provenance to get one. Now every GLB the Forge produces, across every generation lane (free NIM, Forge Pro, rigged avatars, self-host TRELLIS/Hunyuan, async GCP workers), gets an ed25519-signed content credential the moment it's materialized, and every first download of a paid asset from the x402 asset bazaar gets one too, with the hash and a verify link returned right in the download response. Signing and storage are free and local, no Solana write and no spend, so there's nothing to gate; the separate paid anchor_provenance upgrade, which additionally commits the hash on-chain, is untouched and still available. A credential is keyed by content hash, so it's issued exactly once per file no matter how many times a lane or endpoint touches it. Model pages now show the same verified / tampered / unverified badge the 3D viewer already had, and a third party can check any model for free with GET /api/provenance. The owner can turn automatic issuance off platform-wide with PROVENANCE_AUTO_DISABLE=true; nothing else about verification changes if they do.",
+ "tags": [
+ "feature",
+ "security"
+ ]
+ },
{
"date": "2026-10-12",
"title": "Restyle and part edits now prove they kept the rig, not just claim it",
diff --git a/docs/provenance.md b/docs/provenance.md
index e8e2639ef..df4644348 100644
--- a/docs/provenance.md
+++ b/docs/provenance.md
@@ -1,12 +1,24 @@
# Verifiable 3D provenance — content credentials for AI-generated models
-Every model three.ws generates can carry a **signed content credential** — creator, prompt, model/provider, lineage, timestamp, and the GLB's content hash — with that hash **anchored on Solana**. Anyone can verify a model's authenticity and detect tampering **for free**, no account and no crypto. Anchoring (the on-chain write) is the paid, Claude-track action.
+Every model three.ws generates, and every GLB sold through the paid asset bazaar, carries a **signed content credential by default** (creator, prompt, model/provider, lineage, timestamp, and the GLB's content hash) with no action required and no spend. Anyone can verify a model's authenticity and detect tampering **for free**, no account and no crypto. A credential can also, separately, be **anchored on Solana** so its hash is independently checkable on-chain; that on-chain write stays the paid, Claude-track action, and is never required to get a `verified` result.
- **Spec:** [`specs/PROVENANCE_3D.md`](https://github.com/nirholas/three.ws/blob/main/specs/PROVENANCE_3D.md) (CC0)
- **Pure core:** [`api/_lib/provenance-3d.js`](https://github.com/nirholas/three.ws/blob/main/api/_lib/provenance-3d.js)
+- **Automatic free issuance:** [`api/_lib/auto-provenance.js`](https://github.com/nirholas/three.ws/blob/main/api/_lib/auto-provenance.js), wired into every forge generation lane and every first paid-asset download
- **Free verify:** `GET /api/provenance?src=<glbUrl>` and the `verify_provenance` MCP tool
- **Paid anchor:** the `anchor_provenance` MCP tool
+## Signed by default
+
+Generate a model through Forge (any lane) or buy one through the asset bazaar and the credential already exists by the time you have the file, nobody has to call a tool first. Signing is local (ed25519) and storage is a small JSON object in R2; there's no on-chain write and no spend on this path, so it's safe to run on every single asset. A paid asset-download response includes the hash and a ready-to-share verify link directly:
+
+```jsonc
+{ "ok": true, "slug": "pole-dancer-rumba", "downloadUrl": "…",
+ "glbSha256": "e3b0c4…", "verifyUrl": "https://three.ws/api/provenance?hash=e3b0c4…" }
+```
+
+The owner can turn this off platform-wide with `PROVENANCE_AUTO_DISABLE=true`; there's no per-asset opt-out, and turning it off never touches `verify_provenance`, `GET /api/provenance`, or `anchor_provenance`, which keep working on whatever was already issued.
+
> **v2 credentials also carry a signed physics grade.** Alongside authorship, a credential can assert what a rigid-body solver would make of the mesh: watertight or not, real meters or a generator's unit box, its exact volume and inertia tensor. An unsigned grade is a claim anyone can forge; this one is not. See [Simulation readiness](./sim-readiness.md). Credentials signed under v1, before the field existed, keep verifying byte for byte, permanently.
## Verify a model (free, public)
@@ -50,7 +62,7 @@ Agents get the same verdict from the `verify_provenance` tool on the [3D Studio
- `tampered` — a credential exists but the bytes changed (even one byte) or the credential was altered.
- `unknown` — no credential is on record for this model.
-The 3D viewer (`/viewer?src=…`) shows the result as a badge: **✓ Verified · three.ws** (links to the anchor), **⚠ Tampered**, or **Unverified**.
+The 3D viewer (`/viewer?src=…`) and every model page (`/m/:id`) show the result as a badge: **✓ Verified · three.ws** (links to the anchor), **⚠ Tampered**, or **Unverified**.
## Anchor a credential (paid, Claude track)
diff --git a/public/changelog-recent.json b/public/changelog-recent.json
index 82e98de93..5c2890f7c 100644
--- a/public/changelog-recent.json
+++ b/public/changelog-recent.json
@@ -1,11 +1,11 @@
{
- "generated_at": "2026-10-12T09:12:05.233Z",
+ "generated_at": "2026-10-12T09:45:15.975Z",
"generated_by": "scripts/build-page-index.mjs from data/pages.json + data/changelog.json",
"site": {
"name": "three.ws",
"url": "https://three.ws"
},
- "total": 4043,
+ "total": 4044,
"complete": false,
"full_feed": "/changelog.json",
"entries": [
@@ -70,6 +70,17 @@
"feature"
]
},
+ {
+ "date": "2026-10-12",
+ "type": "update",
+ "title": "Every generated and purchased model now ships with a signed provenance credential, free, by default",
+ "summary": "Content credentials (specs/PROVENANCE_3D.md) used to be an on-demand, Claude-track action: you had to call anchor_provenance to get one. Now every GLB the Forge produces, across every generation lane (free NIM, Forge Pro, rigged avatars, self-host TRELLIS/Hunyuan, async GCP workers), gets an ed25519-signed content credential the moment it's materialized, and every first download of a paid asset from the x402 asset bazaar gets one too, with the hash and a verify link returned right in the download response. Signing and storage are free and local, no Solana write and no spend, so there's nothing to gate; the separate paid anchor_provenance upgrade, which additionally commits the hash on-chain, is untouched and still available. A credential is keyed by content hash, so it's issued exactly once per file no matter how many times a lane or endpoint touches it. Model pages now show the same verified / tampered / unverified badge the 3D viewer already had, and a third party can check any model for free with GET /api/provenance. The owner can turn automatic issuance off platform-wide with PROVENANCE_AUTO_DISABLE=true; nothing else about verification changes if they do.",
+ "link": "/docs/provenance",
+ "tags": [
+ "feature",
+ "security"
+ ]
+ },
{
"date": "2026-10-12",
"type": "update",
@@ -1536,16 +1547,6 @@
"tags": [
"launch"
]
- },
- {
- "date": "2026-10-09",
- "type": "launch",
- "title": "The Crawl",
- "summary": "Watch three.ws agents read the open web in real browsers, live. Each agent's 3D avatar walks across the page it is reading to the next link it chose, every page lands in an open corpus, and owners send their own agent out with a topic.",
- "link": "/crawl",
- "tags": [
- "launch"
- ]
}
]
}
diff --git a/public/changelog.json b/public/changelog.json
index 23f7034e1..b0708f855 100644
--- a/public/changelog.json
+++ b/public/changelog.json
@@ -1,5 +1,5 @@
{
- "generated_at": "2026-10-12T09:12:05.210Z",
+ "generated_at": "2026-10-12T09:45:15.950Z",
"generated_by": "scripts/build-page-index.mjs from data/pages.json + data/changelog.json",
"site": {
"name": "three.ws",
@@ -67,6 +67,17 @@
"feature"
]
},
+ {
+ "date": "2026-10-12",
+ "type": "update",
+ "title": "Every generated and purchased model now ships with a signed provenance credential, free, by default",
+ "summary": "Content credentials (specs/PROVENANCE_3D.md) used to be an on-demand, Claude-track action: you had to call anchor_provenance to get one. Now every GLB the Forge produces, across every generation lane (free NIM, Forge Pro, rigged avatars, self-host TRELLIS/Hunyuan, async GCP workers), gets an ed25519-signed content credential the moment it's materialized, and every first download of a paid asset from the x402 asset bazaar gets one too, with the hash and a verify link returned right in the download response. Signing and storage are free and local, no Solana write and no spend, so there's nothing to gate; the separate paid anchor_provenance upgrade, which additionally commits the hash on-chain, is untouched and still available. A credential is keyed by content hash, so it's issued exactly once per file no matter how many times a lane or endpoint touches it. Model pages now show the same verified / tampered / unverified badge the 3D viewer already had, and a third party can check any model for free with GET /api/provenance. The owner can turn automatic issuance off platform-wide with PROVENANCE_AUTO_DISABLE=true; nothing else about verification changes if they do.",
+ "link": "/docs/provenance",
+ "tags": [
+ "feature",
+ "security"
+ ]
+ },
{
"date": "2026-10-12",
"type": "update",
diff --git a/public/changelog.xml b/public/changelog.xml
index bcc079e54..d44c8cc0c 100644
--- a/public/changelog.xml
+++ b/public/changelog.xml
@@ -54,6 +54,14 @@
<category>feature</category>
<description>A new free grade answers the question a game engine's import step asks that neither glTF validation nor simulation readiness does: draw calls, material count, texel density against the mesh's real-world size, a per-level triangle budget for a LOD chain, and whether the mesh is cheap and closed enough to use as its own physics collider. GET/POST /api/3d/engine-qa grades any public GLB (format=stl exports a watertight mesh for printing); the same browser-only checks run with zero network cost in Rig Doctor, and the full grade with a one-click upgrade in the GLB viewer, through a shared &lt;engine-qa&gt; panel component. The underlying LOD builder (packages/glb-tools's buildLodChain, real meshoptimizer decimation tagged with MSFT_lod) is now also available on generation: send { &quot;lods&quot;: true } to POST /api/forge and the finished creation gets a combined LOD-chain variant alongside its delivered mesh, the same opt-in, fire-and-forget pattern as the existing web-delivery variant.</description>
</item>
+ <item>
+ <title>Every generated and purchased model now ships with a signed provenance credential, free, by default</title>
+ <link>https://three.ws/docs/provenance</link>
+ <guid isPermaLink="false">2026-10-12:Every generated and purchased model now ships with a signed provenance credential, free, by default</guid>
+ <pubDate>Mon, 12 Oct 2026 12:00:00 GMT</pubDate>
+ <category>feature</category>
+ <description>Content credentials (specs/PROVENANCE_3D.md) used to be an on-demand, Claude-track action: you had to call anchor_provenance to get one. Now every GLB the Forge produces, across every generation lane (free NIM, Forge Pro, rigged avatars, self-host TRELLIS/Hunyuan, async GCP workers), gets an ed25519-signed content credential the moment it's materialized, and every first download of a paid asset from the x402 asset bazaar gets one too, with the hash and a verify link returned right in the download response. Signing and storage are free and local, no Solana write and no spend, so there's nothing to gate; the separate paid anchor_provenance upgrade, which additionally commits the hash on-chain, is untouched and still available. A credential is keyed by content hash, so it's issued exactly once per file no matter how many times a lane or endpoint touches it. Model pages now show the same verified / tampered / unverified badge the 3D viewer already had, and a third party can check any model for free with GET /api/provenance. The owner can turn automatic issuance off platform-wide with PROVENANCE_AUTO_DISABLE=true; nothing else about verification changes if they do.</description>
+ </item>
<item>
<title>Real VRM avatars: spring bones, expressions, and .vrma clips via @pixiv/three-vrm</title>
<link>https://three.ws/docs/avatar-engines</link>
diff --git a/public/features.json b/public/features.json
index 605525fd7..b67a9e67b 100644
--- a/public/features.json
+++ b/public/features.json
@@ -1,5 +1,5 @@
{
- "generated_at": "2026-10-12T09:12:05.196Z",
+ "generated_at": "2026-10-12T09:45:15.934Z",
"generated_by": "scripts/build-page-index.mjs from data/pages.json",
"site": {
"name": "three.ws",
diff --git a/specs/PROVENANCE_3D.md b/specs/PROVENANCE_3D.md
index a4adcadf3..7fbf2a993 100644
--- a/specs/PROVENANCE_3D.md
+++ b/specs/PROVENANCE_3D.md
@@ -2,13 +2,13 @@
**Version `threews.provenance.3d.v2`** · Open specification · License: CC0 / public domain
-> Pure core: `api/_lib/provenance-3d.js`. Free verify: `GET /api/provenance` and the `verify_provenance` MCP tool. Paid anchor: `anchor_provenance` MCP tool. Guide: [`docs/provenance.md`](https://github.com/nirholas/three.ws/blob/main/docs/provenance.md).
+> Pure core: `api/_lib/provenance-3d.js`. Automatic free issuance: `api/_lib/auto-provenance.js`. Free verify: `GET /api/provenance` and the `verify_provenance` MCP tool. Paid anchor: `anchor_provenance` MCP tool. Guide: [`docs/provenance.md`](https://github.com/nirholas/three.ws/blob/main/docs/provenance.md).
## The problem
-As AI-generated 3D floods the web, **authenticity** becomes the scarce thing. A content credential answers: who created this model, from what prompt, by which model, when, and its full lineage — and proves the bytes weren't altered since. This is C2PA-style provenance for 3D: anti-deepfake by construction. Verification is public and free; the credential hash is anchored on Solana so anyone can confirm it independently.
+As AI-generated 3D floods the web, **authenticity** becomes the scarce thing. A content credential answers: who created this model, from what prompt, by which model, when, and its full lineage, and proves the bytes weren't altered since. This is C2PA-style provenance for 3D: anti-deepfake by construction. Every GLB the platform generates or sells gets one of these credentials automatically, for free, with no action required; verification is public and free too. A credential can optionally also be anchored on Solana so anyone can confirm the hash independently on-chain.
-The **verify path carries zero payment, wallet, or coin surface**, so it drops into crypto-free app stores. Only the **anchor** (the on-chain write) is a paid/Claude-track action.
+The **default and verify paths both carry zero payment, wallet, or coin surface**, so they drop into crypto-free app stores. Only the **anchor** (the on-chain write) is a paid/Claude-track action.
## The credential
@@ -57,6 +57,23 @@ The credential is stored and transmitted inside a signed envelope:
The signed bytes are the credential serialized with **recursively sorted keys** (`canonicalize` in the pure core), so signing and verifying produce identical bytes regardless of key order. The signature is ed25519 over those bytes; `credentialHash` is the sha256 of those bytes.
+## Automatic issuance (free, on by default)
+
+Every GLB that leaves the platform gets a credential without anyone calling `anchor_provenance` or `verify_provenance` first. Signing is local (ed25519 against `ATTEST_AGENT_SECRET_KEY`) and storage is R2; there is no on-chain write and no spend, so this runs automatically with no gate to clear.
+
+Issuance core: `autoCredentialForBytes({ buffer, assetId, creator, prompt, model, provider, lineage })` in `api/_lib/auto-provenance.js`. It is fire-and-forget everywhere it is called: a signing or storage failure never blocks or slows the asset it's credentialing.
+
+Wired at two chokepoints that between them cover every GLB the platform hands out:
+
+1. **Forge generation:** `materializeCreation` in `api/_lib/forge-store.js`, the single completion path every generation lane funnels through (free NIM, Forge Pro, rigged avatars, self-host TRELLIS/Hunyuan, async GCP workers, NVIDIA NIM). A credential is issued the moment a creation's bytes are final, before the response reaches the caller.
+2. **Paid asset downloads:** `GET /api/x402/asset-download`, via `ensureAssetCredential`. The first download of a `paid_assets` row hashes the GLB, issues the credential, and caches the hash on the row (`paid_assets.glb_sha256`) so a repeat buyer's re-download never re-hashes the file. The response carries `glbSha256` and `verifyUrl` once the credential exists.
+
+Idempotency: a credential is keyed by content hash (`provenance/<glbSha256>.json`), and issuance checks for an existing object first. A credential is evidence; evidence that already exists is never reissued, auto or not.
+
+**Owner opt-out:** set `PROVENANCE_AUTO_DISABLE=true` to turn off automatic issuance platform-wide. Nothing else changes: `verify_provenance`, `GET /api/provenance`, and the paid `anchor_provenance` upgrade all keep working exactly as before, they simply stop receiving new automatic entries. There is no per-asset or per-user opt-out; this is an owner-level switch only.
+
+Tests: `tests/auto-provenance.test.js` (signing, storage, idempotency, disabled flag, missing key, store-failure resilience, URL-fetch variant).
+
## Anchoring (paid, Claude/web3 track)
`anchor_provenance(glb_url, …)`: