@three-blocks/devtools 1.0.0-alpha.176.g8ff8a72e6369 → 1.0.0-alpha.190.g3ffe5c0ecc9c

package/CHANGELOG.md

@@ -1,8 +1,33 @@
 # @three-blocks/devtools
 
-## 1.0.0-alpha.176.g8ff8a72e6369
+## 1.0.0-alpha.190.g3ffe5c0ecc9c
+
+- Tools: Private tool releases now deliver the current Blender and CLI bundles.
+
+- Tools: Example optimization now waits for loading and exits cleanly after parity.
+
+- Website: Mobile navigation now opens from a responsive menu on every page.
+
+- Website: Ocean water fills mobile screens without camera controls fighting touch.
+
+- Website: Skinned text now starts quickly from a prebuilt Japanese MSDF atlas.
+
+- Website: The overview sphere is floor-centered and pushes the pile more strongly.
+
+- Website: Spotlight Type stays steady while scrolling.
+
+- Website: Mobile smoke responds forcefully while water fills portrait screens and follows touch.
+
+- Website: The 3D smoke scene now uses a clean, star-free sky.
+
+- Website: Liquid Bunny stays clearly lit in portrait views.
+
+- Website: Baked Motion loading posters now match the live scene size on portrait screens.
+
+- Website: Release pages show the exact version with a short changelog.
+
+- Packages: Built from `3ffe5c0ecc9c`.
 
-- ci: keep alpha readiness release-scoped (`8ff8a72e6369`).
 
 This changelog is generated from Changesets.
 

package/LICENSE

@@ -1,5 +1,4 @@
-Required Notice: Copyright (c) 2025-2026 Three Blocks — https://threejs-blocks.com
-Required Notice: AI/ML training and dataset use are not licensed; text-and-data-mining rights reserved (EU 2019/790 Art. 4(3)). See NOTICE.
+Required Notice: Copyright (c) 2025-2026 ロリンジャー株式会社 (Rohlinger K.K.), doing business as Three.js Blocks (https://threejs-blocks.com)
 
 # PolyForm Noncommercial License 1.0.0
 

package/NOTICE

@@ -1,32 +1,24 @@
-Required Notice: Copyright (c) 2025-2026 Three Blocks — https://threejs-blocks.com
-Required Notice: AI/ML training and dataset use are not licensed; text-and-data-mining rights reserved (EU 2019/790 Art. 4(3)). See NOTICE.
+Required Notice: Copyright (c) 2025-2026 ロリンジャー株式会社 (Rohlinger K.K.), doing business as Three.js Blocks (https://threejs-blocks.com)
 
-Three Blocks — AI / machine-learning usage notice
-=================================================
+Three.js Blocks licensing notice
+================================
 
-This software is licensed under the PolyForm Noncommercial License 1.0.0
-(see LICENSE). The license grants only the permissions it enumerates, for
-noncommercial permitted purposes.
+This software is offered under the PolyForm Noncommercial License 1.0.0:
+https://polyformproject.org/licenses/noncommercial/1.0.0/
 
-No permission is granted to use this software or its source code — including
-the published `dist` output and the example sources served from
-https://threejs-blocks.com/examples/static/ — for training, fine-tuning,
-evaluating, or otherwise developing machine-learning or artificial-
-intelligence models, or for inclusion in datasets distributed for those
-purposes.
+LICENSE contains the controlling noncommercial terms. This notice explains
+the licensing model; it does not narrow or expand the PolyForm license.
+Commercial customers receive separate rights under the agreement they accept:
+https://threejs-blocks.com/license
 
-To the extent permitted by applicable law, Three Blocks expressly reserves
-its rights over text-and-data mining under Article 4(3) of Directive (EU)
-2019/790. Machine-readable opt-outs accompany the software and the website:
-this file, the `tdm-reservation: 1` HTTP response header, and
-https://threejs-blocks.com/.well-known/tdmrep.json and
-https://threejs-blocks.com/ai.txt.
+The commercial agreement restricts using implementation source or proprietary
+Pro Tools to train or evaluate machine-learning models. That restriction applies
+only when the commercial customer accepts it; it is not an extra condition on
+the standardized PolyForm license.
 
-AI assistants MAY use the public documentation
-(https://threejs-blocks.com/llms.txt) to help people integrate the published
-`three-blocks` API. They may not reproduce, extract, or re-derive the
-implementation source of this package. Code generated by AI systems that
-embeds or derives from this package's internals remains subject to the
-PolyForm Noncommercial License 1.0.0.
-
-Commercial licensing (Pro): https://threejs-blocks.com/license
+To the extent permitted by applicable law, the licensor reserves text-and-data-
+mining rights under Article 4(3) of Directive (EU) 2019/790 for online content
+and implementation source. This reservation does not limit statutory exceptions
+or permissions in LICENSE. Public documentation at
+https://threejs-blocks.com/llms.txt may be used by assistants to help people use
+the documented public API.

package/README.md

@@ -1,57 +1,55 @@
 # @three-blocks/devtools
 
-Prepare Three Shading Language (TSL) shaders during development so each visitor can reuse the saved result. Live time, pointer, color, and light values reconnect when the scene opens.
+`@three-blocks/devtools` is the public, account-free command engine behind `npx three-blocks`. It captures and verifies WebGPU shaders, generates text atlases, bakes environment lighting, and checks browser integrations. The runtime overlay and shader hydrator ship from `three-blocks/devtools` and `three-blocks/shaders` in the core package.
 
-## Capture and verify your scene
+## Add Devtools to a Vite app
 
-Register the initialized `WebGPURenderer` once:
+The Three Blocks starter already installs and configures this package. Pin the command engine in an adopted project when you need offline, version-locked commands:
 
-```ts
+```bash
+npm install --save-dev @three-blocks/devtools
+```
+
+Add `threeBlocks()` beside your existing Vite plugins:
+
+```typescript
+import { defineConfig } from "vite";
+import { threeBlocks } from "three-blocks/vite";
+
+export default defineConfig(({ mode }) => ({
+  plugins: [threeBlocks({ shaders: { strict: mode === "strict" } })],
+}));
+```
+
+Register the page-owned `WebGPURenderer` once:
+
+```typescript
 import { registerDevtools } from "three-blocks/devtools";
 
 registerDevtools({ renderer });
 ```
 
-Then capture:
+Open the development overlay and click **Capture** for the current scene. Use the command for a route matrix, automated regeneration, or continuous integration (CI):
 
-```sh
+```bash
 npx three-blocks shaders capture
 ```
 
-The first run creates `three-blocks.shaders.json` with a default `/` route when the
-project does not have one. Capture writes both the committed source artifact under
-`.three-blocks/shaders/` and its zero-import browser asset under
-`public/three-blocks/shaders/`. The registration line discovers that asset, holds the
-first renderer build while it loads, and installs it in development and production.
-An explicit `installShaderCache()` call remains available for advanced routing.
+The first command-line capture creates `three-blocks.shaders.json` with a default `/` route when the project has no shader configuration. Capture writes a committed source artifact under `.three-blocks/shaders/` and a browser manifest under `public/three-blocks/shaders/`. `registerDevtools()` loads the matching manifest before the first shader build. Use `installShaderCache()` only when the app owns custom manifest transport.
 
-Vite is the golden path: add `threeBlocks()` from `three-blocks/vite`. In a Next.js,
-webpack, Rollup, or esbuild project, the capture command detects the bundler and checks
-its provider adapter. When wiring is missing, it prints the exact configuration diff
-and asks before applying it. Use `--yes` only after reviewing that diff when running
-non-interactively. The command starts a project-local Next.js server or builds and
-serves `dist/`, `build/`, or `out/` automatically.
+For Next.js, webpack, Rollup, or esbuild, the capture command detects the bundler and checks its provider adapter. Missing wiring produces an exact configuration diff and requires confirmation. Review that diff before using `--yes` in a noninteractive shell. The command starts a project-local Next.js server or builds and serves `dist/`, `build/`, or `out/`.
 
-Use `--driver static --serve <dir>` for a nonstandard build directory, or `--url
-<url>` to attach to a server you started. Explicit driver and URL choices never edit
-bundler configuration.
+Use `--driver static --serve build_directory` for a nonstandard build directory. Use `--url http://localhost:3000` to attach to a transformed server you started. Explicit driver and URL choices never edit bundler configuration.
 
-The overlay changes from **Live** to **Precompiled** after a fresh capture loads. It shows the skipped TSL builds and the project-specific **TSL build time saved** when `timing.local.json` matches the current capture. Shader-relevant edits mark both the capture and its timing stale, so the app builds live until you capture again.
+The overlay changes from **Live** to **Precompiled** after a fresh capture loads. Each capture writes a receipt-matched estimate to `.three-blocks/shaders/timing.local.json`; `--commit-timing` also writes a shareable, hardware-labelled `timing.json`. `shaders test` replaces the local estimate with a median from repeated runs. The overlay reports skipped Three Shading Language (TSL) builds and estimated TSL work avoided only while timing matches the current receipt.
 
 `WebGLRenderer` stays on live shader building. `WebGPURenderer` also uses the live path when it selects a WebGL fallback.
 
 ### Three.js r185 compatibility patch
 
-Every adapter applies the same version-gated patch to `three/build/three.webgpu.js` in memory. It never writes `node_modules`. The r185 patch contains four independent changes:
+Shader precompilation supports Three.js `>=0.185.0 <0.186.0`. Every adapter applies the same version-gated transform to `three/build/three.webgpu.js` in memory and never writes `node_modules`. Exact source anchors fail closed on unknown or partially patched builds. Current captures require precompiled manifest version `3` and shader receipt transform version `50`; recapture older artifacts instead of editing them.
 
-- [#34068](https://github.com/mrdoob/three.js/pull/34068) adds the node-builder debug callback used by capture.
-- [#34069](https://github.com/mrdoob/three.js/pull/34069) gives named node buffers deterministic labels.
-- [#34070](https://github.com/mrdoob/three.js/pull/34070) adds the public node-builder state provider used by hydration.
-- The local `compileAsync()` patch collects pipeline promises across one compile pass, yields after 8 ms work slices, then awaits the pipelines together. It captures each WebGPU error-scope promise before concurrent pipelines settle so the scopes remain balanced.
-
-Each change has exact source anchors and fails closed on drift or partial application. Current captures require precompiled manifest version `3` and shader receipt transform version `3`; recapture older artifacts instead of editing them.
-
-Delete an upstream backport when the supported Three.js release contains it. Reevaluate the local batching patch against each release. See [Maintain Three.js WebGPU compatibility](../../docs/maintenance/three-webgpu-release-compatibility.md) for markers, removal conditions, and verification.
+The [Three.js WebGPU compatibility reference](../../docs/maintenance/three-webgpu-release-compatibility.md) defines the released r185 patches, source markers, removal conditions, and verification gates.
 
 ### Manual bundler adapters
 
@@ -59,39 +57,36 @@ These are the manual equivalents of the diff that `shaders capture` offers.
 
 esbuild:
 
-```js
+```typescript
+import { build } from "esbuild";
 import { createEsbuildShaderPlugin } from "@three-blocks/devtools/transform";
 
 await build({
-  // ...
   plugins: [createEsbuildShaderPlugin({ root: process.cwd() })],
 });
 ```
 
 Rollup:
 
-```js
+```typescript
 import { createRollupShaderPlugin } from "@three-blocks/devtools/transform";
 
 export default {
-  // ...
   plugins: [createRollupShaderPlugin({ root: process.cwd() })],
 };
 ```
 
 webpack:
 
-```js
+```typescript
 import { withThreeBlocksWebpack } from "@three-blocks/devtools/transform";
 
-export default withThreeBlocksWebpack({
-  // ...
-});
+export default withThreeBlocksWebpack({});
 ```
 
 Next.js:
 
-```ts
+```typescript
 import type { NextConfig } from "next";
 import { withThreeBlocksNext } from "@three-blocks/devtools/transform";
 
@@ -102,153 +97,103 @@ const nextConfig: NextConfig = {
 export default withThreeBlocksNext(nextConfig);
 ```
 
-The adapters always install the production provider hook. They add capture
-instrumentation only when `THREE_BLOCKS_SHADER_TOOL=1`; a tool-managed build or server
-sets that automatically. For a manually started webpack or Next.js server, set the
-variable yourself and run `shaders capture --url http://localhost:3000`.
+The adapters always install the production provider hook. They add capture instrumentation only when `THREE_BLOCKS_SHADER_TOOL=1`; a tool-managed build or server sets that automatically. For a manually started webpack or Next.js server, set the variable yourself and run `npx three-blocks shaders capture --url http://localhost:3000`.
 
-## Reference
+## Command reference
 
-The public command surface is `npx three-blocks`. This package also exposes the direct `three-blocks-devtools` binary for package-local and repository maintenance.
+Use `npx three-blocks` in applications. This package also exposes `three-blocks-devtools` for package-local and repository maintenance.
 
-All commands support `--json` (stable machine output; human output stays line-oriented and
-uncolored when piped). Static status validates `three-blocks.json`, committed shader
-manifests, installed compatibility versions, the installed public `three-blocks/shaders`
-runtime closure, and independently discovered shader-relevant source inputs. Runtime
-evidence (worker, codecs, HMR) comes from the last `browser smoke` run and is reported as
-a dated verification, never as live state.
+| Command                                       | Result                                                                      |
+| --------------------------------------------- | --------------------------------------------------------------------------- |
+| `npx three-blocks status`                     | Report worker, asset, shader, and text state                                |
+| `npx three-blocks shaders`                    | Verify shader freshness without a browser or graphics processing unit (GPU) |
+| `npx three-blocks shaders capture --if-stale` | Capture changed scenes and write a local timing estimate                    |
+| `npx three-blocks shaders test --parity-only` | Run one live and precompiled correctness pair per scene                     |
+| `npx three-blocks shaders test`               | Run parity, repeated timing, and the published-page soak                    |
+| `npx three-blocks shaders watch`              | Recapture when shader inputs change                                         |
+| `npx three-blocks text generate`              | Generate multi-channel signed distance field (MSDF) atlases and receipts    |
+| `npx three-blocks text status`                | Verify text assets and glyph coverage                                       |
+| `npx three-blocks environment bake`           | Bake a prefiltered environment KTX2                                         |
+| `npx three-blocks browser smoke`              | Verify development readiness and hot module replacement (HMR)               |
+| `npx three-blocks browser preview`            | Build and verify the production preview                                     |
+
+All commands support `--json` and `--reporter json`. `status` reads generated `three-blocks.json` metadata when present; adopted projects need only their shader or text configuration. Static status validates committed artifacts, compatibility versions, the installed `three-blocks/shaders` runtime closure, and discovered shader inputs. Browser evidence comes from the last `browser smoke` run and remains a dated verification, not live state.
 
 ### Precompile WebGPU shaders
 
 ```bash
-three-blocks-devtools shaders status --check       # no browser or GPU
-three-blocks-devtools shaders capture --if-stale   # isolated GPU context per scene
-three-blocks-devtools shaders test --parity-only   # one fast zero-build + pixel pair
-three-blocks-devtools shaders test                 # parity + timing + published-page soak
-three-blocks-devtools shaders test --skip-browser --mode strict
-                                                    # CI freshness/schema gate
-three-blocks-devtools shaders watch --debounce 250
+npx three-blocks shaders status --check
+npx three-blocks shaders capture --if-stale
+npx three-blocks shaders test --parity-only
+npx three-blocks shaders test
+npx three-blocks shaders watch --debounce 250
 ```
 
-Projects may declare the complete capture matrix in `three-blocks.shaders.json`:
+Add `three-blocks.shaders.json` when the project needs multiple routes, a semantic scene name, or an explicit readiness signal:
 
 ```json
 {
   "schemaVersion": 1,
   "scenes": [
-    { "key": "default", "url": "/?scene=default" },
-    { "key": "text", "url": "/?scene=text", "requiresText": true }
+    { "key": "main", "url": "/" },
+    { "key": "text", "url": "/text", "requiresText": true }
   ],
-  "settleFrames": 60,
-  "timeoutMs": 240000,
-  "viewport": { "width": 1024, "height": 640 },
-  "parity": { "frames": 90, "channelTolerance": 8, "maxDiffRatio": 0.01 },
-  "readiness": { "global": "__THREE_BLOCKS_READY__" },
-  "publicDir": "public",
-  "allowLiveBuilds": true
+  "readiness": { "global": "__THREE_BLOCKS_READY__" }
 }
 ```
 
-Readiness is optional. Its global may be `true` or a promise; a selector is also
-supported. With no override, the engine waits for its settled-frame and first-frame
-contract and assumes nothing about application DOM.
-
-This workflow is the main purpose of `@three-blocks/devtools`. Capture uses a version-gated r185 transform supplied by the selected bundler adapter. The transform journals real
-render and compute `NodeBuilder` states, resolves stable keys through the public
-`three-blocks/shaders` cache, exposes loopback readiness/telemetry, and uploads a typed payload.
-The generated application owns no capture harness or patcher, and this tool never writes to
-`node_modules`. A Three.js version or transform-anchor mismatch fails closed.
-
-All configured scenes must pass before the tool replaces deterministic
-`.three-blocks/shaders/<scene>.webgpu.ts` modules; `meta.json` is the last commit marker. It records
-runtime/tool/schema versions, a `threeBlocksShaderClosure` hash, shader-relevant app-source hashes,
-bytes, stage coverage, and skipped render/compute builds. App hashing begins at scene modules and
-real shader registrations and follows only local runtime imports. Unrelated modules, type-only
-imports, and DOM copy are not freshness inputs. Relevant source changes during capture abort the
-commit. `watch` is explicitly opt-in and permits
-only one running capture plus one coalesced rerun; failures preserve the prior committed receipt.
-Explicit stable keys remain the clearest choice for complex, conditional capture matrices.
-When an otherwise unregistered application or Three-internal build is first observed,
-capture assigns it a deterministic scene-scoped key and records that automatic namespace
-in the manifest. Set `allowLiveBuilds: false` when a project intentionally requires any
-build that still cannot be addressed to fail capture.
-
-`shaders test` first repeats the no-GPU matrix inspection. Its browser gate then proves that the
-live baseline builds every registered render pipeline and compute kernel, while the fresh path
-performs zero registered builds, covers render and compute injection independently, reports no
-misses, reaches first-frame readiness, renders non-black output, and matches deterministic pixels.
-Successful scenes are checkpointed immediately against their scene receipt and the shared
-runtime/tool contract, so a later failure can resume at the missing scene. `--parity-only` runs
-one live/precompiled pair without timing warmups, repeats, or the published-page soak. The default
-mode retains those slower measurements and production-page checks. A parity observation that
-returns no result is capped at 10 seconds.
-On parity failure it writes live, precompiled, and diff PNGs under
-`.three-blocks/shaders/parity/`.
+Readiness is optional. Its global may be `true` or a promise; a selector is also supported. With no override, the engine waits for its settled-frame and first-frame contract and assumes nothing about the application DOM.
+
+Capture observes real render and compute `NodeBuilder` states, then writes a deterministic pooled v3 manifest. The generated application owns no capture harness, and the tooling never writes to `node_modules`. Missing keys, stale receipts, unsupported Three.js versions, and hydration mismatches fail closed to live shader building.
+
+Artifact writes are transactional. `meta.json` records runtime, tool, schema, source-input, byte, and stage-coverage evidence. Relevant source changes during capture abort the write, and failures preserve the prior committed receipt. Explicit stable keys remain the clearest choice for conditional capture matrices; otherwise, capture assigns deterministic scene-scoped keys. Set `allowLiveBuilds: false` when every build must belong to the declared matrix.
+
+`shaders test` first repeats the GPU-free matrix inspection. Its browser gate proves that the live baseline builds every registered render pipeline and compute kernel. The fresh path must perform zero registered builds, report no misses, reach first-frame readiness, render non-black output, and match deterministic pixels.
+
+Successful scenes are checkpointed against their scene receipt and the shared runtime and tool contract. A later run can resume at the missing scene. `--parity-only` runs one live and precompiled pair without timing warmups, repeats, or the published-page soak. The default mode retains those measurements and production-page checks. A parity observation is capped at 10 seconds. Failures write live, precompiled, and diff PNGs under `.three-blocks/shaders/parity/`.
 
 ### Verify a browser integration
 
 ```bash
-three-blocks-devtools browser smoke --route / --json
-three-blocks-devtools browser smoke --hmr src/offscreen/meshes/Scene.ts
+npx three-blocks browser smoke --route / --json
+npx three-blocks browser smoke --hmr src/offscreen/meshes/Scene.ts
+npx three-blocks browser preview --route /
 ```
 
-The smoke gate loads the project's real Vite config on an ephemeral loopback port. It requires
-the visible OffscreenCanvas worker plus `workerReady`, `assetsReady`, and `compileEnd`; it also
-requires `textReady` when the Vite text configuration is enabled. Every configured Draco and
-KTX2 route is fetched, the lazy Meshopt decoder is initialized, page and console errors fail the
-run, and both the WebGPU screenshot and readable 2D panels are checked for an all-black frame.
+The smoke gate loads the project's Vite config on an ephemeral loopback port. It requires the visible OffscreenCanvas worker plus `workerReady`, `assetsReady`, and `compileEnd`. It also requires `textReady` when the Vite text configuration is enabled. Every configured Draco and KTX2 route is fetched, the lazy Meshopt decoder is initialized, and page or console errors fail the run. The gate checks the WebGPU screenshot and readable 2D panels for an all-black frame.
 
 The command reads the starter's built-in readiness check. Application tutorials describe the visible **Starting**, **Ready**, **Precompiled**, and **Live** states instead of this maintainer contract. Contributors can inspect the exact protocol in the [maintainer browser-verification reference](../../docs/maintenance/browser-verification.md).
 
-`--hmr <project-relative-module>` emits a synthetic watcher change through Vite for an already
-loaded scene module. It runs the real HMR graph without writing or touching source and verifies
-that the browser acknowledges the update while lifecycle readiness remains stable.
+`--hmr project_relative_module` emits a synthetic watcher change through Vite for an already loaded scene module. It runs the HMR graph without changing source and verifies that the browser acknowledges the update while lifecycle readiness remains stable.
 
-Only the two documented ambient diagnostics exported in `DOCUMENTED_BROWSER_NOISE` are filtered:
-Three Inspector's invalid `extensions.json` response and Chromium's experimental WebGPU notice.
+Only the two ambient diagnostics exported in `DOCUMENTED_BROWSER_NOISE` are filtered: Three Inspector's invalid `extensions.json` response and Chromium's experimental WebGPU notice.
 
 ### Bake environment lighting
 
 ```bash
-three-blocks-devtools environment bake --size 256
-three-blocks-devtools environment bake --output src/assets/environment/studio.pmrem.ktx2 --json
+npx three-blocks environment bake --size 256
+npx three-blocks environment bake \
+  --output src/assets/environment/studio.pmrem.ktx2 --json
 ```
 
-The browser entry renders Three.js `RoomEnvironment` through WebGPU and exports the PMREM CubeUV
-atlas. Node validates RGBA16F topology, zstd-compresses at a deterministic level, decodes every
-level byte-for-byte, records the final SHA-256 checksum, and transactionally replaces the KTX2
-and JSON metadata pair. Size, time, upload, path, and file bounds are enforced. `--no-zstd` is an
-explicit compatibility opt-out.
+The browser entry renders Three.js `RoomEnvironment` through WebGPU and exports the PMREM CubeUV atlas. Node validates RGBA16F topology, compresses it with zstd at a deterministic level, decodes every level byte-for-byte, records the SHA-256 checksum, and transactionally replaces the KTX2 and JSON metadata pair. Size, time, upload, path, and file bounds are enforced. `--no-zstd` is an explicit compatibility opt-out.
 
-Both GPU commands accept `--root <path>` for integration workspaces that intentionally do
-not carry generated-project metadata. Normal generated projects are discovered automatically.
+Both GPU commands accept `--root project_path` for integration workspaces that intentionally omit generated-project metadata. Generated projects are discovered automatically.
 
 ### Ship it
 
-Commit `.three-blocks/shaders/` and the generated public manifests, then add one
-GPU-less CI command:
+Commit `.three-blocks/shaders/` and the generated public manifests, then add one GPU-free CI command:
 
-```sh
+```bash
 npx three-blocks shaders test --skip-browser --mode strict
 ```
 
-Use `--reporter json` for CI annotations. Run the full `shaders test` in an optional
-WebGPU lane. Production selects the hydration-only `three-blocks/devtools` condition:
-overlay and stats implementation bytes are absent, while the bounded
-`three-blocks/shaders` runtime remains. Opt into its local production console receipt
-with `threeBlocks({ stats: { production: true } })`; no telemetry leaves the app.
+Use `--reporter json` for CI annotations. Run the full `shaders test` in an optional WebGPU lane. Production selects the hydration-only `three-blocks/devtools` condition. Overlay and statistics implementation bytes are absent, while the bounded `three-blocks/shaders` runtime remains. Opt into its local production console receipt with `threeBlocks({ stats: { production: true } })`; no telemetry leaves the app.
 
-Text artifacts remain `missing` or `invalid` until configured glyph coverage, checksums,
-orientation, and KTX2 decode round-trip validation succeed. No command performs account or
-entitlement checks.
+Text artifacts remain `missing` or `invalid` until configured glyph coverage, checksums, orientation, and KTX2 decode round-trip validation succeed. No command performs account or entitlement checks.
 
-## License
+## License and Pro terms
 
-Free for personal and noncommercial projects. Commercial projects are covered
-by the Pro plan's lifetime license — each project you start while your plan is
-active is licensed forever, for the versions released while it was active. No
-runtime gating.
+This package uses [PolyForm Noncommercial 1.0.0](./LICENSE). Personal and noncommercial projects can install and run every Devtools command without an account, Pro seat, or runtime entitlement check. Keep the Required Notice when redistributing the package.
 
-This package uses the [PolyForm Noncommercial 1.0.0 license](./LICENSE). Keep
-the Required Notice when redistributing it; full commercial terms are at
-[threejs-blocks.com/license](https://threejs-blocks.com/license).
+Pro is a per-seat subscription. During an active period, each person who starts or develops a new commercial Project, adopts a later software version, or downloads or updates a Pro Tool needs a named seat. Each Project started during that period receives a lifetime commercial license for versions released during the same period. After cancellation, the Project may be maintained, updated, and distributed with those covered versions, and Pro Tool versions obtained during the active period may keep running locally and offline for that Project. Starting another commercial Project, adopting a later release, or downloading or updating a Pro Tool requires an active subscription. Devtools remains account-free because commercial permission is a license boundary, not a feature gate. See the [Commercial License Agreement](https://threejs-blocks.com/license) and [pricing](https://threejs-blocks.com/pricing).