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.

feat: prepare NVIDIA catalog submissions

nirholas7212937642c8
diff --git a/docs/nvidia-apps-catalog-listing.md b/docs/nvidia-apps-catalog-listing.md
index 983bf1ee4..3cdfa5456 100644
--- a/docs/nvidia-apps-catalog-listing.md
+++ b/docs/nvidia-apps-catalog-listing.md
@@ -6,15 +6,27 @@ Related docs: [nvidia-inception.md](./nvidia-inception.md) (membership overview)
---
-## Status: product record filed, public listing not live (2026-08-14)
+## Status: product record filed, public listing not live (2026-09-14)
-The portal shows the product row (`three.ws | Shipping | GPU Accelerated`), but a search for `three.ws` on the public catalog returns 0 results. **Re-verified 2026-09-04:** still 0 results on the public catalog, and the portal record is still the uncorrected one below (Used: cuBLAS, CUDA Python, CUDA Toolkit, cuDNN; Considering: DeepVariant NIM, Riva, TensorRT, Triton, Omniverse Kit, Audio2Face), so neither step 1 nor step 2 has happened yet. That is expected, not a bug: **the portal record and the public catalog are two different systems.**
+The portal shows the product row (`three.ws | Shipping | GPU Accelerated`), but a search for `three.ws` on the public catalog returns 0 results. **Public search re-verified 2026-09-14:** still 0 results. The last authenticated portal check on 2026-09-04 showed the uncorrected record below (Used: cuBLAS, CUDA Python, CUDA Toolkit, cuDNN; Considering: DeepVariant NIM, Riva, TensorRT, Triton, Omniverse Kit, Audio2Face). That is expected, not a bug: **the portal record and the public catalog are two different systems.**
- **Portal > Profile > Products** makes the company benefits-eligible and feeds NVIDIA's internal recommendation engine. The portal's own wording is "we **may** feature it in the personalized recommendations we share with our customers."
- **The public catalog** ([marketplace.nvidia.com/en-us/enterprise/applications](https://marketplace.nvidia.com/en-us/enterprise/applications/), filtered view for startups at [nvidia.com/en-gb/accelerated-applications/inception](https://www.nvidia.com/en-gb/accelerated-applications/inception/)) is curated and published by NVIDIA. Submissions are reviewed on a rolling basis and approval is subject to availability and fit. Nothing in the portal auto-publishes.
So there are exactly two things to do: make the record obviously worth featuring, then ask for the listing.
+### Current intake route
+
+The public [NVIDIA AI Accelerated](https://www.nvidia.com/en-us/ai-data-science/ai-accelerated/)
+page still displays an **Apply Now** action, but on 2026-09-14 that action resolved to
+`mynvidia.force.com/NVPartners/s/nvidiaaiacceleratedprogram` and returned 404. Do not wait
+on or repeatedly retry that dead link. The working route is:
+
+1. correct the product record in the authenticated Inception portal;
+2. keep the catalog request in the existing `[email protected]` thread;
+3. ask for the replacement intake URL in the scheduled 2026-09-25 follow-up if NVIDIA has
+ not replied before then.
+
### 1. Correct the portal record (the record understates the stack)
As filed, the record lists only CUDA libraries as used, and parks every NVIDIA platform product under "Considering." That reads as a CUDA consumer, not a digital-human app, and it is wrong against the shipping code. Move these to **Technologies Used**:
@@ -108,7 +120,13 @@ All in the repo, web-ready:
- Lockups: `public/brand/three-ws-lockup-on-dark.png`, `public/brand/three-ws-lockup-on-light.png`
- Social/OG image: `public/og-image.png`
- Full press kit: `public/brand/three-ws-press-kit.zip`
-- Screenshots: capture live from https://three.ws/forge (generation in progress plus result), https://three.ws/agora (3D world), and https://three.ws/character-library (rigged character grid) at 1920x1080
+- NVIDIA product page, 1920x1080: [`marketing/nvidia-inception/assets/three-ws-nvidia-1920x1080.png`](../marketing/nvidia-inception/assets/three-ws-nvidia-1920x1080.png)
+- Audio2Face browser demo, 1920x1080: [`marketing/nvidia-inception/assets/three-ws-audio2face-1920x1080.png`](../marketing/nvidia-inception/assets/three-ws-audio2face-1920x1080.png)
+- Forge product page, 1920x1080: [`marketing/nvidia-inception/assets/three-ws-forge-1920x1080.png`](../marketing/nvidia-inception/assets/three-ws-forge-1920x1080.png)
+
+Use the NVIDIA product page first and the Audio2Face demo second. The Forge screenshot is
+valid product evidence but includes `$THREE` holder controls, so it should not lead an
+NVIDIA catalog submission.
## Second product record: the `<agent-3d>` digital-human embed
diff --git a/docs/nvidia-apps-catalog-request.md b/docs/nvidia-apps-catalog-request.md
index bb80c452b..ade9586fa 100644
--- a/docs/nvidia-apps-catalog-request.md
+++ b/docs/nvidia-apps-catalog-request.md
@@ -188,7 +188,49 @@ None are required; every asset is linked in the body and the links are live. Att
- Lockups: [three-ws-lockup-on-dark.png](../public/brand/three-ws-lockup-on-dark.png), [three-ws-lockup-on-light.png](../public/brand/three-ws-lockup-on-light.png)
- Press kit (6.3 MB, may trip attachment limits; the link in the body is safer): [public/brand/three-ws-press-kit.zip](../public/brand/three-ws-press-kit.zip)
-Screenshots are deliberately not attached. The email offers them on request, which is a cheaper second touch than guessing the spec now. If they ask, capture 1920x1080 from [/forge](https://three.ws/forge) (generation in progress plus result), [/agora](https://three.ws/agora), and [/character-library](https://three.ws/character-library).
+Screenshots were deliberately not attached to the original email. Catalog-ready 1920x1080
+captures were prepared on 2026-09-14 for the next touch:
+
+- [`marketing/nvidia-inception/assets/three-ws-nvidia-1920x1080.png`](../marketing/nvidia-inception/assets/three-ws-nvidia-1920x1080.png)
+- [`marketing/nvidia-inception/assets/three-ws-audio2face-1920x1080.png`](../marketing/nvidia-inception/assets/three-ws-audio2face-1920x1080.png)
+- [`marketing/nvidia-inception/assets/three-ws-forge-1920x1080.png`](../marketing/nvidia-inception/assets/three-ws-forge-1920x1080.png)
+
+Lead with the NVIDIA product page and Audio2Face images. The Forge capture includes token
+holder controls and is supporting product evidence rather than the lead NVIDIA image.
+
+## September 25 follow-up
+
+Send this as a reply in the existing thread only if NVIDIA has not answered by
+2026-09-25. Attach the NVIDIA product-page and Audio2Face screenshots above.
+
+```text
+Hello,
+
+Following up on the Accelerated Apps Catalog request for three.ws below. Our
+Inception product record identifies the application as Shipping / GPU
+Accelerated, and I have attached current 1920x1080 captures of the NVIDIA stack
+page and the browser-native Audio2Face-3D demo.
+
+The public NVIDIA AI Accelerated page still displays an Apply Now link, but it
+currently resolves to the retired Salesforce path
+mynvidia.force.com/NVPartners/s/nvidiaaiacceleratedprogram and returns 404. Is
+there a replacement intake form, or should the application continue through
+this Inception thread?
+
+The product, demo, technical documentation, and engineering evidence remain
+live at:
+
+- https://three.ws/nvidia
+- https://three.ws/demos/audio2face
+- https://three.ws/docs/nvidia-models
+- https://three.ws/blog/image-to-3d-on-nvidia-l4-and-blackwell
+
+Thank you,
+
+Nicholas
+three.ws
+https://three.ws
+```
## After you send
diff --git a/docs/nvidia-ngc-listing.md b/docs/nvidia-ngc-listing.md
index 9a03b7668..3b35aa101 100644
--- a/docs/nvidia-ngc-listing.md
+++ b/docs/nvidia-ngc-listing.md
@@ -26,13 +26,18 @@ Single image in, textured GLB out, on one L4. It is the strongest of the GPU
fleet for an outside user because its model is MIT-licensed, its weights are not
baked into the image, and it collects nothing.
-**Three of NVIDIA's four prerequisites are met today. The fourth (the EULA) is
-met by this change.** What actually blocks a submission is not NVIDIA's list, it
-is that the container currently assumes it is running inside our Google Cloud
-project. An NGC user has no `GCS_BUCKET`, so the image as built refuses to start
-for them. That is [gate 1](#gate-1-the-container-must-run-outside-our-cloud-project)
-below, and it is the only substantial piece of work between here and a
-submission.
+**The two portability blockers are now implemented.** The container keeps its
+production GCS backend when `GCS_BUCKET` is set and switches to a mounted local
+output volume when it is not. The CUDA architecture list is also a build
+argument, so the NGC build can target a broader GPU matrix without changing the
+production L4 image.
+
+One published prerequisite still needs resolution: NVIDIA asks for an
+automatically multi-GPU-capable application, while this inference server
+deliberately runs one job on one GPU. The NGC intake should ask whether
+service-per-GPU orchestration satisfies that requirement or whether NVIDIA
+expects in-container model replication. Do not claim this prerequisite as met
+until NVIDIA answers or a multi-GPU implementation is validated.
## Prerequisite audit
@@ -41,7 +46,7 @@ NVIDIA's four published prerequisites, each against the code:
| NVIDIA prerequisite | Status | Evidence |
|---|---|---|
| Containerized using the CUDA 9 or later base container | **Met** | `FROM nvidia/cuda:12.1.1-cudnn8-devel-ubuntu22.04` in [workers/model-trellis/Dockerfile](../workers/model-trellis/Dockerfile). Eight GPU workers in the tree are built on `nvidia/cuda` 12.1 to 12.8. |
-| GPU accelerated, automatically multi-GPU capable, runs on Pascal or newer | **Partly met** | GPU acceleration is the whole point of the image: TRELLIS with nvdiffrast, diffoctreerast, diff-gaussian-rasterization and NVIDIA Kaolin, all compiled with nvcc at build time. It is single-GPU by design (`MAX_CONCURRENT` defaults to 1, one L4 fits exactly one inference) and its kernels are compiled for `sm_89` only. See [gate 2](#gate-2-the-kernels-are-compiled-for-one-gpu-generation). |
+| GPU accelerated, automatically multi-GPU capable, runs on Pascal or newer | **Partly met** | GPU acceleration is implemented with TRELLIS, nvdiffrast, diffoctreerast, diff-gaussian-rasterization, and NVIDIA Kaolin. The architecture list is now configurable, but the server remains single-GPU by design. See [gate 2](#gate-2-the-kernels-are-compiled-for-one-gpu-generation) and [gate 3](#gate-3-multi-gpu-requirement-needs-nvidia-guidance). |
| An end-user license agreement for the application | **Met by this change** | [NVIDIA NGC Container EULA](https://three.ws/legal/nvidia-ngc-eula), source at [public/legal/nvidia-ngc-eula.html](../public/legal/nvidia-ngc-eula.html). It covers the Apache-2.0 code, the third-party components, and the fact that the image ships no weights. |
| Container does not collect personal data or violate GDPR | **Met** | The worker has no analytics, telemetry, or reporting of any kind: a search of [workers/model-trellis](../workers/model-trellis) for `posthog`, `analytics`, `telemetry`, `mixpanel`, and `sentry` returns nothing. The only outbound calls it makes are the ones the caller asks for, and those go through the SSRF guard in [worker_security.py](../workers/model-trellis/worker_security.py). |
@@ -61,23 +66,17 @@ container is our serving code plus a CUDA build, and the user brings the model.
### Gate 1: the container must run outside our cloud project
-[main.py](../workers/model-trellis/main.py) reads `GCS_BUCKET = os.environ["GCS_BUCKET"]`
-at import and uploads every finished mesh with `storage.Client()`. On an NGC
-user's machine there is no bucket and no credential, so the process exits before
-it serves a request. Weights are already fine: `WEIGHTS_DIR` defaults to a local
-path and `WEIGHTS_GCS_URI` staging is optional, so a user who downloads the
-TRELLIS weights from Hugging Face and mounts them is served by the existing code
-path.
+**Status: implemented.**
-What the listing needs is an output backend selected by configuration:
+[main.py](../workers/model-trellis/main.py) now treats `GCS_BUCKET` as optional.
+When it is set, production behavior remains GCS-backed. When it is unset, the
+worker uses `OUTPUT_DIR` (default `/output`) for atomic task records and GLBs,
+returns `result_url` plus `result_path`, and serves authenticated downloads from
+`GET /results/{task_id}.glb`. `GET /health` reports the active backend.
-- Keep the current behaviour byte-for-byte when `GCS_BUCKET` is set, so nothing
- about the production forge lane changes.
-- When it is unset, write the GLB to `OUTPUT_DIR` (default `/output`, a mounted
- volume) and return a path plus a `GET /results/{task_id}.glb` download route
- instead of a `storage.googleapis.com` URL.
-- Report the active backend in `GET /health` so an operator can tell which mode
- the instance came up in.
+Path and persistence behavior is isolated in
+[storage_backend.py](../workers/model-trellis/storage_backend.py) and covered by
+[test_storage_backend.py](../workers/model-trellis/test_storage_backend.py).
The worker's tests run inside the built image (`docker run --rm model-trellis
python3 test_app_contract.py`), so this change is verified by a GPU build, not
@@ -85,19 +84,31 @@ from a laptop. Budget one Cloud Build run for it.
### Gate 2: the kernels are compiled for one GPU generation
+**Status: configurable, validation pending.**
+
The Dockerfile sets `TORCH_CUDA_ARCH_LIST="8.9"`, deliberately, to keep our own
builds fast on the L4 fleet. An image compiled for `sm_89` alone does not run on
the Ampere, Hopper, or Blackwell hardware an NGC user is most likely to have,
and NVIDIA's prerequisite reads "Pascal or newer".
-The fix is a build argument and a wider arch list for the published image only,
-but the arch matrix has to be decided by an actual build: the compiled
-extensions (diffoctreerast, diff-gaussian-rasterization, nvdiffrast) are not all
-buildable on every architecture in that range, and a list that fails to compile
-is worse than a narrow one that works. Determine the real matrix in the same
-Cloud Build run as gate 1 and pin what compiles.
+The Dockerfile now exposes `TORCH_CUDA_ARCH_LIST` as a build argument and keeps
+`8.9` as the production default. The first NGC candidate build should use
+`8.0;8.6;8.9;9.0+PTX`, then run on at least one Ampere or Hopper GPU plus the
+existing L4 validation. Pin the final matrix only after those compiled
+extensions pass the real build and inference checks.
+
+### Gate 3: multi-GPU requirement needs NVIDIA guidance
+
+**Status: open.**
-### Gate 3: the NGC partner legal agreement
+The current server serializes inference on one GPU because a TRELLIS job fills
+most of an L4. Horizontal replicas provide production concurrency, but the NGC
+FAQ specifically says "automatically multi-GPU capable." Ask NVIDIA whether
+one service replica per GPU is acceptable for this inference workload. If it
+is not, build and validate process-per-GPU model replication before pushing the
+staging image.
+
+### Gate 4: the NGC partner legal agreement
Owner action. It is step 1 of NVIDIA's published process and nothing technical
depends on it, so it can be signed while gates 1 and 2 are being built.
@@ -147,6 +158,44 @@ which also cuts the published image size.
- EULA: https://three.ws/legal/nvidia-ngc-eula
- Upstream model: https://github.com/microsoft/TRELLIS
+## NGC partner intake form, paste-ready
+
+The live NVIDIA form asks for these product fields. Identity, job-title, and
+location selections must match the account holder's legal information.
+
+**Organization / University Name:** three.ws
+
+**Industry:** Media and Entertainment
+
+**Product Name:** three.ws TRELLIS Mesh Server
+
+**Link to Product Home Page:** https://three.ws/forge
+
+**What does your product do?**
+
+> three.ws TRELLIS Mesh Server is a containerized GPU inference service that
+> turns one image, or multiple views of the same subject, into a textured GLB
+> 3D asset. It uses Microsoft TRELLIS with NVIDIA CUDA, Kaolin, nvdiffrast, and
+> custom CUDA extensions. The container supports authenticated asynchronous
+> jobs, configurable quality tiers, SSRF-protected image intake, health checks,
+> and local mounted-volume output without requiring a cloud account. Model
+> weights are mounted separately and are not included in the image.
+
+**List NVIDIA GPUs supported by your Product:**
+
+> NVIDIA L4 is the verified production target. RTX PRO 6000 Blackwell has been
+> validated for the heavy image-to-3D lane. The portable NGC architecture
+> matrix for Ampere, Ada, and Hopper will be finalized during NVIDIA staging
+> and validation.
+
+**Question for the NVIDIA contact after submission:**
+
+> This inference service schedules one model replica per GPU and scales through
+> service replicas because one TRELLIS job uses most of an L4. Does NGC's
+> automatically multi-GPU-capable prerequisite accept service-per-GPU
+> orchestration, or should the staging image implement process-per-GPU model
+> replication inside one container?
+
**Quick start (goes in the listing body, once gate 1 lands)**
```bash
@@ -162,6 +211,16 @@ curl -X POST http://localhost:8080/infer \
-d '{"images":["https://three.ws/avatars/thumbs/default.png"],"tier":"standard"}'
```
+Poll the returned task, then download its local result with the same bearer:
+
+```bash
+curl -H "Authorization: Bearer choose-a-secret" \
+ http://localhost:8080/tasks/TASK_ID
+
+curl -L -H "Authorization: Bearer choose-a-secret" \
+ -o result.glb http://localhost:8080/results/TASK_ID.glb
+```
+
## What is owner-gated
Everything that leaves the machine. Submitting the partner form, signing the
@@ -170,7 +229,8 @@ and none of them are an agent's call:
1. Submit **Become an NGC Software Partner** at [nvidia.com/en-us/gpu-cloud/ngc-software-partners](https://www.nvidia.com/en-us/gpu-cloud/ngc-software-partners/). Mention the Inception membership in the form; it is the same company record.
2. Sign the NGC Partner Legal Agreement when it comes back.
-3. Approve the Cloud Build run that produces the publishable image (gates 1 and 2).
+3. Confirm the multi-GPU interpretation with NVIDIA, then run the portable image
+ build and GPU validation.
## Verification log
@@ -181,8 +241,8 @@ and none of them are an agent's call:
| Base images are CUDA 12.x | `grep FROM workers/*/Dockerfile` | Eight GPU workers on `nvidia/cuda` 12.1 to 12.8 |
| The container collects nothing | `grep -rniE "posthog|analytics|telemetry|mixpanel|sentry" workers/model-trellis` | No matches |
| Weights are not baked into the image | [workers/model-trellis/README.md](../workers/model-trellis/README.md) and the Dockerfile | Weights mount at `/weights`; no `COPY` of any checkpoint |
-| `GCS_BUCKET` is a hard requirement | [main.py](../workers/model-trellis/main.py) | `os.environ["GCS_BUCKET"]` at import, no fallback |
-| Kernels are `sm_89` only | [Dockerfile](../workers/model-trellis/Dockerfile) | `TORCH_CUDA_ARCH_LIST="8.9"`, no PTX |
+| Standalone storage | [main.py](../workers/model-trellis/main.py), [storage_backend.py](../workers/model-trellis/storage_backend.py) | Local mounted-volume mode implemented; GCS remains the production path |
+| CUDA architecture configuration | [Dockerfile](../workers/model-trellis/Dockerfile) | Production defaults to `8.9`; catalog builds can pass a wider list |
| Upstream licenses | Worker READMEs | TRELLIS MIT, MDM MIT, Hunyuan3D non-commercial |
## Related
diff --git a/docs/partners/openai-ibm-nvidia-growth-plan.md b/docs/partners/openai-ibm-nvidia-growth-plan.md
index e9010f4e8..a036d217b 100644
--- a/docs/partners/openai-ibm-nvidia-growth-plan.md
+++ b/docs/partners/openai-ibm-nvidia-growth-plan.md
@@ -15,7 +15,7 @@ stage is a small number of portal actions, emails, and well-timed follow-ups.
|---|---|---|---|---|
| 1 | IBM watsonx Orchestrate Agent Catalog | Request the BYOL `APP_ID`, then submit the Remote MCP listing through Agent Connect | Low | Enterprise discovery inside IBM's governed agent catalog |
| 2 | OpenAI Developer Showcase | Submit the completed Showcase packet | Low | Public proof, a durable OpenAI-hosted project page, and a stronger app-review story |
-| 3 | NVIDIA AI Accelerated | Correct the Inception product record and use the official **Apply Now** route for validation and catalog consideration | Low | Product validation and visibility in NVIDIA's accelerated application ecosystem |
+| 3 | NVIDIA AI Accelerated | Correct the Inception product record and continue the existing catalog request through the program team | Low | Product validation and visibility in NVIDIA's accelerated application ecosystem |
| 4 | IBM Partner Plus marketing | Activate My Digital Marketing, obtain the Build-track marketing kit, and reopen the promised IBM page and social support | Low | Campaign assets and IBM-owned distribution without another engineering project |
| 5 | NVIDIA Inception visibility | Continue the existing catalog/Showcase/co-marketing request; follow up on **2026-09-25** if unanswered | Low | Member spotlight, official assets, technical-team introductions, and event access |
| 6 | NVIDIA NGC Catalog | Package one useful GPU service as a maintained container and complete publisher onboarding | Medium | A self-contained NVIDIA catalog artifact developers can deploy |
@@ -125,11 +125,14 @@ Full internal audit: [IBM Partner Plus opportunities](./ibm-partner-plus.md).
## NVIDIA
-### 1. Complete the AI Accelerated application path
+### 1. Complete the AI Accelerated portal path
NVIDIA's current AI Accelerated page invites software and solution providers to apply,
validate performance on NVIDIA platforms, and increase application visibility. This is the
-best public catalog path for the full three.ws product.
+best public catalog target for the full three.ws product. As of 2026-09-14, however, its
+public **Apply Now** link resolves to a retired Salesforce URL and returns 404. Use the
+Inception portal product record and the existing program-team thread until NVIDIA supplies
+a replacement intake URL.
Before applying, correct the Inception portal product record:
@@ -139,9 +142,9 @@ Before applying, correct the Inception portal product record:
they ship;
- retain the verified CUDA, Kaolin, nvdiffrast, L4, and RTX PRO 6000 Blackwell usage.
-Then use the official **Apply Now** route and treat the existing Inception email as the
-human escalation path. The public catalog remains curated even though the program has an
-application form.
+The public catalog remains curated. Treat the corrected portal record as the internal
+application and the existing Inception email as the catalog request. Ask for the current
+intake URL in the scheduled follow-up rather than waiting on the dead public link.
### 2. Continue the Inception co-marketing request without restarting it
@@ -230,7 +233,7 @@ audience and product.
| Sep 14 to 18 | Submit the OpenAI Showcase packet | Owner | confirmation email or submission ID |
| Sep 14 to 18 | Request IBM Agent Connect BYOL `APP_ID` | Owner | IBM thread and assigned ID |
| Sep 14 to 18 | Activate IBM My Digital Marketing and verify Partner Plus Directory profile | Owner | portal screenshots and live profile URL |
-| Sep 14 to 18 | Correct the NVIDIA Inception product record and use the AI Accelerated application route | Owner | saved portal record and application receipt |
+| Sep 14 to 18 | Correct the NVIDIA Inception product record | Owner | saved portal record |
| Sep 18 to 24 | Publish the prepared OpenAI and NVIDIA technical posts on a measured cadence | Owner | live URLs added to the publishing tracker |
| Sep 25 | Follow up once with NVIDIA if the September 4 request has no reply | Owner | reply or next checkpoint |
| By Sep 29 | Decide on IBM TechXchange attendance | Owner | registration or explicit close |
@@ -245,7 +248,7 @@ audience and product.
- [IBM Partner Plus go-to-market benefits](https://www.ibm.com/partnerplus/marketing)
- [Selling on IBM Cloud Catalog](https://www.ibm.com/products/cloud/partners/catalog-sell)
- [IBM Cloud catalog onboarding requirements](https://cloud.ibm.com/docs/sell?topic=sell-selling-clouds)
-- [NVIDIA AI Accelerated](https://www.nvidia.com/en-us/ai-data-science/ai-accelerated/)
+- [NVIDIA AI Accelerated](https://www.nvidia.com/en-us/ai-data-science/ai-accelerated/) (program page; its public application link returned 404 on 2026-09-14)
- [NVIDIA Developer Program and Inception benefits](https://developer.nvidia.com/developer-program)
- [NVIDIA GTC for startups and VCs](https://www.nvidia.com/gtc/startups/)
- [NVIDIA NGC Catalog](https://catalog.ngc.nvidia.com/)
diff --git a/docs/partners/opportunities.md b/docs/partners/opportunities.md
index 8caa310aa..1941c0840 100644
--- a/docs/partners/opportunities.md
+++ b/docs/partners/opportunities.md
@@ -81,7 +81,7 @@ The work is done or nearly done. A human on our side has to act.
| IBM Agent Connect (BYOL MCP listing) | Fully prepared | `APP_ID` request email, then Concierge | Owner |
| AWS Marketplace | Integration deployed, listing never created | Create the product in the portal | Owner |
| NVIDIA NGC Catalog | Prerequisites cleared | One build plus partner legal agreement | Owner + eng |
-| NVIDIA Accelerated Apps Catalog | Portal record filed, copy written | Send the inclusion email | Owner |
+| NVIDIA Accelerated Apps Catalog | Inclusion email sent 2026-09-04; portal record still understates the shipping stack | Correct the portal record, then follow up in the same thread on 2026-09-25 if unanswered | Owner |
| OpenAI Plugin Directory | Eligible | Submit | Owner |
| OpenAI Showcase Gallery | Eligible, open web form | Submit | Owner |
| IBM My Digital Marketing | Entitled, never used | Request access and the Build track marketing kit | Owner |
diff --git a/marketing/nvidia-inception/README.md b/marketing/nvidia-inception/README.md
index 931a7c544..a9b925a3e 100644
--- a/marketing/nvidia-inception/README.md
+++ b/marketing/nvidia-inception/README.md
@@ -7,6 +7,9 @@ directory closes.
| File | What it is |
| --- | --- |
| [social-copy.md](social-copy.md) | Paste-ready posts for X, LinkedIn, and Telegram, plus the badge and no-endorsement rules every one of them follows. Owner-gated: drafted, not posted. |
+| [assets/three-ws-nvidia-1920x1080.png](assets/three-ws-nvidia-1920x1080.png) | Lead catalog screenshot: the dedicated NVIDIA product and integration page. |
+| [assets/three-ws-audio2face-1920x1080.png](assets/three-ws-audio2face-1920x1080.png) | Browser-native Audio2Face-3D and Riva demo screenshot. |
+| [assets/three-ws-forge-1920x1080.png](assets/three-ws-forge-1920x1080.png) | Supporting Forge product screenshot; it includes token controls, so do not use it as the lead NVIDIA image. |
Strategy lives in docs, not here:
diff --git a/marketing/nvidia-inception/assets/three-ws-audio2face-1920x1080.png b/marketing/nvidia-inception/assets/three-ws-audio2face-1920x1080.png
new file mode 100644
index 000000000..381cad883
Binary files /dev/null and b/marketing/nvidia-inception/assets/three-ws-audio2face-1920x1080.png differ
diff --git a/marketing/nvidia-inception/assets/three-ws-forge-1920x1080.png b/marketing/nvidia-inception/assets/three-ws-forge-1920x1080.png
new file mode 100644
index 000000000..6292afe36
Binary files /dev/null and b/marketing/nvidia-inception/assets/three-ws-forge-1920x1080.png differ
diff --git a/marketing/nvidia-inception/assets/three-ws-nvidia-1920x1080.png b/marketing/nvidia-inception/assets/three-ws-nvidia-1920x1080.png
new file mode 100644
index 000000000..ae16a0be9
Binary files /dev/null and b/marketing/nvidia-inception/assets/three-ws-nvidia-1920x1080.png differ
diff --git a/workers/model-trellis/Dockerfile b/workers/model-trellis/Dockerfile
index 138183e50..9cfbb00ca 100644
--- a/workers/model-trellis/Dockerfile
+++ b/workers/model-trellis/Dockerfile
@@ -9,16 +9,18 @@
# • Attention backend = xformers, NOT flash-attn. flash-attn compiles from
# source for 30+ min and routinely OOMs the builder; xformers is an upstream-
# supported backend and an L4 (sm_89) runs it well. Set via ATTN_BACKEND.
-# • TORCH_CUDA_ARCH_LIST=8.9 — build CUDA kernels only for the L4 (Ada). This
-# cuts compile time massively vs. building every arch.
+# • TORCH_CUDA_ARCH_LIST defaults to 8.9 for the production L4 image. NGC
+# builds can pass a wider list without editing this file.
FROM nvidia/cuda:12.1.1-cudnn8-devel-ubuntu22.04
+ARG TORCH_CUDA_ARCH_LIST="8.9"
+
ENV PYTHONDONTWRITEBYTECODE=1 \
PYTHONUNBUFFERED=1 \
PIP_NO_CACHE_DIR=1 \
DEBIAN_FRONTEND=noninteractive \
- # Build kernels only for the L4 (Ada, sm_89) — keeps source compiles fast.
- TORCH_CUDA_ARCH_LIST="8.9" \
+ # Production defaults to L4 (Ada, sm_89); NGC overrides this build arg.
+ TORCH_CUDA_ARCH_LIST="${TORCH_CUDA_ARCH_LIST}" \
# TRELLIS runtime backends (read at import time in main.py).
ATTN_BACKEND=xformers \
SPCONV_ALGO=native \
@@ -116,8 +118,9 @@ RUN git clone https://github.com/facebookresearch/dinov2.git /opt/dinov2 \
WORKDIR /app
COPY worker_security.py /app/worker_security.py
COPY request_policy.py /app/request_policy.py
+COPY storage_backend.py /app/storage_backend.py
COPY main.py /app/main.py
-COPY test_request_policy.py test_app_contract.py /app/
+COPY test_request_policy.py test_storage_backend.py test_app_contract.py /app/
# Build-time gate, neither half of which needs a GPU:
# 1. The quality tiers, the clamps that keep a caller value from crashing the
@@ -126,7 +129,7 @@ COPY test_request_policy.py test_app_contract.py /app/
# 2. The served contract, against the exact dependency set that will run: the
# TRELLIS import chain (FlexiCubes submodule included), the auth boundary,
# the probe surfaces, request validation, and the SSRF guard.
-RUN python3 -m pytest /app/test_request_policy.py -q \
+RUN python3 -m pytest /app/test_request_policy.py /app/test_storage_backend.py -q \
&& python3 /app/test_app_contract.py
EXPOSE 8080
diff --git a/workers/model-trellis/README.md b/workers/model-trellis/README.md
index 01ea1e1d7..823f8ce5f 100644
--- a/workers/model-trellis/README.md
+++ b/workers/model-trellis/README.md
@@ -11,13 +11,16 @@ first. It runs on one NVIDIA L4 (24 GB) on Cloud Run and is the self-hosted
TRELLIS mesh backend for the `/forge` image→3D lane.
Work is asynchronous: `POST /infer` returns `202` with a `task_id`, and the
-caller polls `GET /tasks/{id}` until the mesh is written to Cloud Storage. The
-finished GLB lands at `gs://$GCS_BUCKET/raw-meshes/trellis/{task_id}.glb` and is
-served back as an `https://storage.googleapis.com/…` URL.
+caller polls `GET /tasks/{id}` until the mesh is ready. With `GCS_BUCKET` set,
+the finished GLB lands at `gs://$GCS_BUCKET/raw-meshes/trellis/{task_id}.glb`
+and is served back as a `storage.googleapis.com` URL. Without `GCS_BUCKET`, the
+standalone container writes tasks and results atomically under `OUTPUT_DIR` and
+serves the mesh from `GET /results/{task_id}.glb`.
## Endpoints
-`POST /infer` and `GET /tasks/{id}` require `Authorization: Bearer $API_KEY`.
+`POST /infer`, `GET /tasks/{id}`, and `GET /results/{task_id}.glb` require
+`Authorization: Bearer $API_KEY`.
`GET /health` and `GET /` are unauthenticated: they carry no secrets, and the
platform reads them to decide whether this lane can take work. Routing
([`api/_lib/forge-lane-health.js`](../../api/_lib/forge-lane-health.js),
@@ -121,6 +124,18 @@ or `failed`.
}
```
+In standalone local mode, a completed task returns `result_url` and
+`result_path` instead of `result_gcs_url`:
+
+```json
+{
+ "task_id": "3f2c…",
+ "status": "done",
+ "result_url": "/results/3f2c….glb",
+ "result_path": "/output/results/3f2c….glb"
+}
+```
+
On failure the record carries an `error` string. A bad image source reports the
actual reason (`image source cdn.example.com unreachable after 3 attempts
(ReadTimeout); check the URL is publicly readable`) because the fault is in the
@@ -143,7 +158,9 @@ forever behind a dead runner. Unknown ids return `404`.
"load_attempts": 1,
"tiers": ["draft", "standard", "high", "max"],
"default_quality": { "ss_steps": 40, "slat_steps": 40, "ss_cfg": 7.5, "slat_cfg": 3.0, "simplify": 0.75, "texture_size": 4096 },
- "rembg_matte": true
+ "rembg_matte": true,
+ "output_backend": "gcs",
+ "output_dir": null
}
```
@@ -188,7 +205,8 @@ against two real error events, which is how a genuine failure goes unnoticed.
| Var | Required | Default | Purpose |
|---|---|---|---|
| `API_KEY` | yes | — | Shared bearer secret (Secret Manager `avatar-reconstruction-key`) |
-| `GCS_BUCKET` | yes | — | Cloud Storage bucket for output meshes |
+| `GCS_BUCKET` | no | - | Cloud Storage bucket for production task state and output meshes. When unset, local storage is used. |
+| `OUTPUT_DIR` | no | `/output` | Mounted task and result volume used when `GCS_BUCKET` is unset |
| `WEIGHTS_DIR` | no | `/weights/trellis-large` | Local path to TRELLIS weights (a mounted GCS volume in prod) |
| `MAX_CONCURRENT` | no | `1` | In-flight inferences; one L4 fits exactly one |
| `ATTN_BACKEND` | no | `xformers` | TRELLIS attention backend, read at import time |
@@ -226,6 +244,33 @@ huggingface-cli download microsoft/TRELLIS-image-large --local-dir /tmp/trellis-
gsutil -m cp -r /tmp/trellis-large gs://three-ws-model-weights/trellis-large/
```
+## Standalone and NGC build
+
+The production image compiles CUDA extensions for L4 (`sm_89`) by default. A
+portable catalog build can supply a wider architecture list without changing
+the Dockerfile:
+
+```bash
+docker build \
+ --build-arg 'TORCH_CUDA_ARCH_LIST=8.0;8.6;8.9;9.0+PTX' \
+ -t three-ws/trellis-mesh-server:latest \
+ workers/model-trellis
+```
+
+Run it with mounted weights and output volumes:
+
+```bash
+docker run --gpus all -p 8080:8080 \
+ -e API_KEY=choose-a-secret \
+ -v /path/to/trellis-image-large:/weights/trellis-large:ro \
+ -v /path/to/output:/output \
+ three-ws/trellis-mesh-server:latest
+```
+
+The local backend persists task JSON under `/output/tasks` and generated GLBs
+under `/output/results`. It does not require Google credentials or make the
+output directory public; downloads retain the worker's bearer authentication.
+
## Tests
The request policy (quality tiers, the clamps that stop a caller value from
@@ -236,7 +281,7 @@ so it can be proven anywhere:
```bash
cd workers/model-trellis
python3 -m pip install pytest httpx
-python3 -m pytest test_request_policy.py -q # 18 tests
+python3 -m pytest test_request_policy.py test_storage_backend.py -q
```
[`test_app_contract.py`](./test_app_contract.py) covers the served surface
diff --git a/workers/model-trellis/main.py b/workers/model-trellis/main.py
index 00008547c..78199077f 100644
--- a/workers/model-trellis/main.py
+++ b/workers/model-trellis/main.py
@@ -18,9 +18,12 @@ API contract (consumed by the Pipeline Controller):
so the background stops bleeding into the mesh. Both are additive: with no
tier and no matte the behaviour is byte-for-byte the historical default.
- GET /tasks/:id → { task_id, status, result_gcs_url?, tier?, matted_views?,
+ GET /tasks/:id → { task_id, status, result_gcs_url?, result_url?, tier?, matted_views?,
quality?, error? }
+ GET /results/:id.glb
+ → generated GLB when OUTPUT_DIR local storage is active
+
GET /health → { ok, model, gpu_available, tiers, rembg_matte, load_error,
load_attempts }. Answers 503 with ok:false once the model
load has spent its retry budget, so a permanently dead
@@ -38,7 +41,8 @@ Model weights pre-population:
Environment variables (README.md carries the full table):
API_KEY shared bearer secret
- GCS_BUCKET Cloud Storage bucket for output meshes
+ GCS_BUCKET optional Cloud Storage bucket for output meshes
+ OUTPUT_DIR local task and result volume when GCS_BUCKET is unset
WEIGHTS_DIR local path to weights (default: /weights/trellis-large)
WEIGHTS_GCS_URI optional gs:// tree staged to local disk at startup
WEIGHTS_LOCAL_DIR where that staging lands (default: /tmp/trellis-weights)
@@ -80,6 +84,7 @@ from urllib.parse import urlsplit
import torch
from fastapi import FastAPI, HTTPException, Header, BackgroundTasks, Response
+from fastapi.responses import FileResponse
from google.api_core.exceptions import NotFound
from google.cloud import storage
from PIL import Image
@@ -100,6 +105,7 @@ from worker_security import (
require_api_key,
safe_error,
)
+from storage_backend import LocalStorage
logging.basicConfig(
level=logging.INFO,
@@ -108,7 +114,8 @@ logging.basicConfig(
log = logging.getLogger("trellis")
API_KEY = os.environ["API_KEY"]
-GCS_BUCKET = os.environ["GCS_BUCKET"]
+GCS_BUCKET = os.environ.get("GCS_BUCKET", "").strip()
+OUTPUT_DIR = os.environ.get("OUTPUT_DIR", "/output")
WEIGHTS_DIR = os.environ.get("WEIGHTS_DIR", "/weights/trellis-large")
MAX_CONCURRENT = int(os.environ.get("MAX_CONCURRENT", "1"))
# Optional: stage the ~3 GB weight tree from GCS to fast local disk at startup,
@@ -148,6 +155,7 @@ DINOV2_HUB_REPO = "facebookresearch/dinov2"
_pipeline = None
_bucket: Optional[storage.Bucket] = None
+_local_storage: Optional[LocalStorage] = None
_sem: Optional[asyncio.Semaphore] = None
_ready: Optional[asyncio.Event] = None
_load_error: Optional[str] = None
@@ -298,8 +306,13 @@ async def _load_pipeline_bg():
@asynccontextmanager
async def lifespan(app: FastAPI):
- global _bucket, _sem, _ready
- _bucket = storage.Client().bucket(GCS_BUCKET)
+ global _bucket, _local_storage, _sem, _ready
+ if GCS_BUCKET:
+ _bucket = storage.Client().bucket(GCS_BUCKET)
+ _local_storage = None
+ else:
+ _bucket = None
+ _local_storage = LocalStorage(OUTPUT_DIR)
_sem = asyncio.Semaphore(MAX_CONCURRENT)
_ready = asyncio.Event()
# Load the ~3 GB pipeline in the BACKGROUND and yield immediately. uvicorn
@@ -450,9 +463,22 @@ async def _matte_via_rembg(src: str, model: str) -> tuple[str, bool]:
def _task_blob(task_id: str):
+ if _bucket is None:
+ raise RuntimeError("GCS task storage is not active")
return _bucket.blob(f"tasks/{task_id}.json")
+def _using_gcs() -> bool:
+ return bool(GCS_BUCKET)
+
+
+def _get_local_storage() -> LocalStorage:
+ global _local_storage
+ if _local_storage is None:
+ _local_storage = LocalStorage(OUTPUT_DIR)
+ return _local_storage
+
+
async def _update_task(task_id: str, **fields) -> dict:
"""Merge `fields` into the task, then persist to GCS as the source of truth
(see the comment on `_tasks`)."""
@@ -460,12 +486,15 @@ async def _update_task(task_id: str, **fields) -> dict:
task.update(fields)
task["updated_at"] = time.time()
loop = asyncio.get_event_loop()
- await loop.run_in_executor(
- None,
- lambda: _task_blob(task_id).upload_from_string(
- json.dumps(task), content_type="application/json"
- ),
- )
+ if _using_gcs():
+ await loop.run_in_executor(
+ None,
+ lambda: _task_blob(task_id).upload_from_string(
+ json.dumps(task), content_type="application/json"
+ ),
+ )
+ else:
+ await loop.run_in_executor(None, _get_local_storage().write_task, task.copy())
return task
@@ -489,8 +518,12 @@ async def _resolve_task(task_id: str) -> dict:
return task
loop = asyncio.get_event_loop()
try:
- data = await loop.run_in_executor(None, _task_blob(task_id).download_as_bytes)
- except NotFound:
+ if _using_gcs():
+ data = await loop.run_in_executor(None, _task_blob(task_id).download_as_bytes)
+ task = json.loads(data)
+ else:
+ task = await loop.run_in_executor(None, _get_local_storage().read_task, task_id)
+ except (NotFound, FileNotFoundError, ValueError):
if task is not None:
# Local-only record (the initial persist raced or failed) — serve
# the in-memory view rather than 404ing a task we know exists.
@@ -500,7 +533,6 @@ async def _resolve_task(task_id: str) -> dict:
raise HTTPException(
status_code=502, detail=safe_error(exc, context="task lookup")
) from exc
- task = json.loads(data)
status = task.get("status")
if status in _TERMINAL_STATUSES:
_tasks[task_id] = task
@@ -623,19 +655,32 @@ async def _run_inference(
glb_bytes = await loop.run_in_executor(None, _generate)
- blob_name = f"raw-meshes/trellis/{task_id}.glb"
- blob = _bucket.blob(blob_name)
- await loop.run_in_executor(
- None,
- lambda: blob.upload_from_string(glb_bytes, content_type="model/gltf-binary"),
- )
- gcs_url = f"https://storage.googleapis.com/{GCS_BUCKET}/{blob_name}"
+ if _using_gcs():
+ blob_name = f"raw-meshes/trellis/{task_id}.glb"
+ blob = _bucket.blob(blob_name)
+ await loop.run_in_executor(
+ None,
+ lambda: blob.upload_from_string(glb_bytes, content_type="model/gltf-binary"),
+ )
+ result_fields = {
+ "result_gcs_url": f"https://storage.googleapis.com/{GCS_BUCKET}/{blob_name}"
+ }
+ result_label = result_fields["result_gcs_url"]
+ else:
+ result_path = await loop.run_in_executor(
+ None, _get_local_storage().write_result, task_id, glb_bytes
+ )
+ result_fields = {
+ "result_url": f"/results/{task_id}.glb",
+ "result_path": str(result_path),
+ }
+ result_label = str(result_path)
elapsed = time.time() - t0
await _update_task(
task_id,
status="done",
- result_gcs_url=gcs_url,
+ **result_fields,
views_used=len(imgs),
tier=tier_key or "default",
matted_views=matted_count,
@@ -644,7 +689,7 @@ async def _run_inference(
)
log.info(
"[%s] done in %.1fs (tier=%s matted=%d q=%s) — %d bytes -> %s",
- task_id, elapsed, tier_key or "default", matted_count, q, len(glb_bytes), gcs_url,
+ task_id, elapsed, tier_key or "default", matted_count, q, len(glb_bytes), result_label,
)
except ImageSourceError as exc:
@@ -764,6 +809,21 @@ async def get_task(task_id: str, authorization: str = Header(...)) -> dict:
return await _resolve_task(task_id)
[email protected]("/results/{task_id}.glb")
+async def get_result(task_id: str, authorization: str = Header(...)):
+ """Download a generated GLB from the mounted local output volume."""
+ _require_api_key(authorization)
+ if _using_gcs():
+ raise HTTPException(status_code=404, detail="local result storage is not active")
+ try:
+ path = _get_local_storage().result_path(task_id)
+ except ValueError as exc:
+ raise HTTPException(status_code=404, detail="result not found") from exc
+ if not path.is_file():
+ raise HTTPException(status_code=404, detail="result not found")
+ return FileResponse(path, media_type="model/gltf-binary", filename=path.name)
+
+
@app.get("/")
async def root() -> dict:
"""Service descriptor, and the answer to the platform's warmth ping.
@@ -781,7 +841,12 @@ async def root() -> dict:
"service": "model-trellis",
"model": "trellis-image-large",
"ready": bool(_ready and _ready.is_set()),
- "endpoints": ["POST /infer", "GET /tasks/{task_id}", "GET /health"],
+ "endpoints": [
+ "POST /infer",
+ "GET /tasks/{task_id}",
+ "GET /results/{task_id}.glb",
+ "GET /health",
+ ],
}
@@ -812,4 +877,6 @@ async def health(response: Response) -> dict:
"tiers": list(TIER_PRESETS),
"default_quality": QUALITY_DEFAULTS,
"rembg_matte": bool(REMBG_SERVICE_URL),
+ "output_backend": "gcs" if _using_gcs() else "local",
+ "output_dir": None if _using_gcs() else str(_get_local_storage().output_dir),
}
diff --git a/workers/model-trellis/storage_backend.py b/workers/model-trellis/storage_backend.py
new file mode 100644
index 000000000..fcf7fc1a1
--- /dev/null
+++ b/workers/model-trellis/storage_backend.py
@@ -0,0 +1,63 @@
+"""Storage primitives for the standalone TRELLIS container.
+
+Production persists tasks and results in GCS because requests can move between
+Cloud Run instances. An NGC user runs one container with a mounted output
+volume, so the same service needs a local backend with atomic writes and strict
+task-id validation.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import uuid
+from pathlib import Path
+
+
+def normalize_task_id(task_id: str) -> str:
+ """Return a canonical UUID or reject a value that could escape the volume."""
+ parsed = uuid.UUID(task_id)
+ canonical = str(parsed)
+ if task_id.lower() != canonical:
+ raise ValueError("task_id must be a canonical UUID")
+ return canonical
+
+
+class LocalStorage:
+ """Durable task metadata and GLB results on a mounted local volume."""
+
+ def __init__(self, output_dir: str | os.PathLike[str]):
+ self.output_dir = Path(output_dir).expanduser().resolve()
+ self.tasks_dir = self.output_dir / "tasks"
+ self.results_dir = self.output_dir / "results"
+ self.tasks_dir.mkdir(parents=True, exist_ok=True)
+ self.results_dir.mkdir(parents=True, exist_ok=True)
+
+ def task_path(self, task_id: str) -> Path:
+ return self.tasks_dir / f"{normalize_task_id(task_id)}.json"
+
+ def result_path(self, task_id: str) -> Path:
+ return self.results_dir / f"{normalize_task_id(task_id)}.glb"
+
+ @staticmethod
+ def _atomic_write(path: Path, data: bytes) -> None:
+ temporary = path.with_suffix(path.suffix + ".tmp")
+ with temporary.open("wb") as handle:
+ handle.write(data)
+ handle.flush()
+ os.fsync(handle.fileno())
+ temporary.replace(path)
+
+ def write_task(self, task: dict) -> Path:
+ path = self.task_path(str(task["task_id"]))
+ payload = json.dumps(task, separators=(",", ":"), sort_keys=True).encode("utf-8")
+ self._atomic_write(path, payload)
+ return path
+
+ def read_task(self, task_id: str) -> dict:
+ return json.loads(self.task_path(task_id).read_text(encoding="utf-8"))
+
+ def write_result(self, task_id: str, glb_bytes: bytes) -> Path:
+ path = self.result_path(task_id)
+ self._atomic_write(path, glb_bytes)
+ return path
diff --git a/workers/model-trellis/test_storage_backend.py b/workers/model-trellis/test_storage_backend.py
new file mode 100644
index 000000000..fa6d14adb
--- /dev/null
+++ b/workers/model-trellis/test_storage_backend.py
@@ -0,0 +1,54 @@
+from __future__ import annotations
+
+import json
+import uuid
+
+import pytest
+
+from storage_backend import LocalStorage, normalize_task_id
+
+
+def test_task_round_trip_survives_process_memory(tmp_path):
+ storage = LocalStorage(tmp_path)
+ task_id = str(uuid.uuid4())
+ task = {"task_id": task_id, "status": "done", "updated_at": 123.0}
+
+ path = storage.write_task(task)
+
+ assert path == tmp_path / "tasks" / f"{task_id}.json"
+ assert storage.read_task(task_id) == task
+ assert json.loads(path.read_text()) == task
+
+
+def test_result_is_written_to_the_mounted_volume(tmp_path):
+ storage = LocalStorage(tmp_path)
+ task_id = str(uuid.uuid4())
+ payload = b"glTF" + bytes(range(32))
+
+ path = storage.write_result(task_id, payload)
+
+ assert path == tmp_path / "results" / f"{task_id}.glb"
+ assert path.read_bytes() == payload
+
+
+ "task_id",
+ ["../escape", "not-a-uuid", "{00000000-0000-0000-0000-000000000000}", "00000000-0000-0000-0000-000000000000/mesh"],
+)
+def test_task_ids_cannot_escape_the_output_volume(task_id):
+ with pytest.raises(ValueError):
+ normalize_task_id(task_id)
+
+
+def test_atomic_writes_leave_no_temporary_files(tmp_path):
+ storage = LocalStorage(tmp_path)
+ task_id = str(uuid.uuid4())
+
+ storage.write_task({"task_id": task_id, "status": "queued"})
+ storage.write_task({"task_id": task_id, "status": "running"})
+ storage.write_result(task_id, b"first")
+ storage.write_result(task_id, b"second")
+
+ assert storage.read_task(task_id)["status"] == "running"
+ assert storage.result_path(task_id).read_bytes() == b"second"
+ assert list(tmp_path.rglob("*.tmp")) == []