@carbonenginejs/runtime-resource 0.7.0 → 0.9.0

package/docs/reference/reload.md

@@ -0,0 +1,107 @@
+# Candidate-first atomic reload
+
+Status: Evolving  
+Scope: `@carbonenginejs/runtime-resource`  
+Audience: Users and integrators  
+Summary: Defines the reload contract that keeps the last published good handle canonical until a distinct candidate has fully succeeded.
+
+## Contract
+
+Reload is candidate-first. When an owner already exists,
+`GetResource(path, { reload: true })` constructs and initializes a distinct
+off-registry candidate without changing ordinary lookup. Calling `Ready()` on
+that candidate, using `GetObject()` / `FetchResource()` with `reload: true`,
+or calling the explicit `ReloadObject()` / `ReloadResource()` helpers starts
+one shared candidate operation that runs the same queued contract:
+
+1. purge-lock the exact former owner and invalidate reusable reads once;
+2. read, convert through the selected format, and publish payload state only
+   on the detached candidate;
+3. require the newest per-key reload token and exact former ownership;
+4. compare-and-swap the fully loaded CPU candidate into MotherLode;
+5. invalidate and clean the displaced handle after the lookup switch.
+
+The manager captures the exact MotherLode, key, former handle, former
+ownership generation, and a newest-request token. Reader, prepare, and
+publication stages mutate only the detached candidate and validate candidate
+authority before and after asynchronous boundaries. A fully loaded CPU
+candidate commits through `CjsMotherLode.ReplaceExpected()` only if the exact
+former owner and newest token still match. The final authority callback and
+exact-record check run immediately before the synchronous map switch, with no
+user cleanup or `await` between the comparison and publication.
+
+After the switch, the displaced ownership generation is invalidated, the
+candidate receives ordinary lifecycle/reconstruction callbacks, and the former
+handle is cleaned exactly once. Existing JavaScript references are not
+retargeted; they keep the displaced handle, while fresh lookup sees the
+committed candidate.
+
+## Failure behavior
+
+Source, format, or publication failure leaves the former handle, state,
+payload, and adapters canonical; the failed candidate's attached payload and
+adapters are cleaned and its original error is retained. An otherwise-
+successful candidate that was superseded, deleted, cleared, or replaced
+rejects with `CJS_RESMAN_STALE_RELOAD_CANDIDATE` and cannot resurrect the
+key. Constructors that return the former singleton are rejected before
+`Initialize()` can mutate it because staging requires a distinct handle.
+
+Failed freshness attempts still invalidate reusable source/format records
+when their work begins; the already-published canonical payload is not
+dependent on those records.
+
+Cleanup errors have explicit sides. Candidate cleanup failure aggregates with
+the original preparation/stale error as
+`CJS_RESMAN_RELOAD_CANDIDATE_CLEANUP_FAILED` while the former owner remains
+canonical. A displaced-owner cleanup failure occurs after publication and
+rejects as `CJS_MOTHERLODE_REPLACE_CLEANUP_FAILED`, whose result explicitly
+reports `committed: true`; the already-good candidate remains canonical.
+
+## Read-cache interaction
+
+`reload: true` synchronously detaches every queued/source/format read record
+for the selected source/path before fresh work starts. Existing consumers
+keep their detached promises; reload does not abort them. Fresh success
+repopulates only caches explicitly requested with `cacheSource: true` or
+`cacheFormat: true`. `InvalidateReadCache(path, { source, sourceRevision })`
+provides the same no-abort invalidation explicitly; omitting
+`sourceRevision` removes all revisions for that source/path. `Delete()`
+remains canonical resource-identity-only, while `Clear()` resets all read
+ledgers. A failed reload preserves the former payload but does not restore
+reusable read-cache entries detached by its explicit freshness request.
+
+## Publication authority and staleness
+
+Every queued, direct, standalone, and candidate resource preparation captures
+an immutable publication authority: the exact MotherLode, canonical key,
+resource handle, and a manager-local ownership generation. The manager
+validates that authority before and after state changes, asynchronous
+reader/format work, and publication. Delete, Clear, successful reload commit,
+or exact-handle reinsertion therefore makes older work reject with
+`CJS_RESMAN_STALE_RESOURCE_OPERATION` before it can enter another state or
+publish. If stale work independently rejects, its original source/format
+error is preserved and `SetError()` is suppressed on the detached handle.
+
+Candidate work is a normal `Wait()` root and blocks synchronous MotherLode
+replacement while active. `Register({ motherLode })` rejects with
+`CJS_RESMAN_ACTIVE_RESOURCE_OPERATIONS` while queued or direct mutations are
+active, including a reload candidate. Normal `Wait()` drains queued roots and
+candidate lineages; a direct caller must await its own load/prepare promise
+before retrying replacement. Canonical and candidate authority prevent late
+publication, but started source or format work is not yet aborted;
+deterministic cleanup applies to the staged candidate resource itself.
+
+## Divergence from Carbon
+
+This availability contract intentionally differs from Carbon.
+`BlueAsyncRes::Reload` cancels/joins work, releases dependent cached data, and
+reloads the same canonical object in place; failure can therefore leave that
+stable handle bad. Carbon MotherLode replacement also switches immediately and
+has no prepare-success gate or rollback. Runtime-resource instead preserves
+the last published good handle until a distinct candidate has succeeded, and
+never silently retargets existing JavaScript references.
+
+## Related documentation
+
+- [MotherLode identity, cache, and retention](motherlode-cache.md)
+- [Queues and the Wait fence](queues.md)

package/docs/reference/texture-arrays.md

@@ -0,0 +1,113 @@
+# Texture arrays and update generations
+
+Status: Evolving  
+Scope: `@carbonenginejs/runtime-resource`  
+Audience: Users and integrators  
+Summary: Defines the texture-array proxy surface, the requested/prepared revision boundary, and the adapter commit contract.
+
+## Layer proxies
+
+Texture-array resources expose one ordinary-looking proxy per ordered layer:
+
+```js
+const textureArray = new CjsTextureArrayRes({
+  paths: [
+    "res:/detail1.dds",
+    "res:/detail2.dds",
+    "res:/detail3.dds"
+  ],
+  layerNames: [ "Detail1Map", "Detail2Map", "Detail3Map" ],
+  updateScheduler: resource => frameQueue.add(resource)
+});
+
+const detail2 = textureArray.GetLayerParameter(1);
+detail2.SetValue("res:/replacement.dds");
+
+detail2.textureRes === textureArray; // true
+```
+
+Proxy setters only update their source path and invalidate the parent. The
+parent is scheduled once even if several proxies change in the same frame.
+The next-frame consumer calls `Update()` or `ConsumeUpdateRequest()` to
+obtain one immutable ordered snapshot. Runtime-resource does not know which
+shader metadata caused the aggregate request; shader packages and engine
+adapters map public parameter names to layer indices.
+
+Public effect parameters remain separate from these internal proxies. Their
+authored paths and individual 2D source resources are not replaced by the
+aggregate. An engine-owned, non-persisted bridge mirrors public changes into
+the fixed internal layers.
+
+## Update generations
+
+`CjsTextureArrayRes` is a derived multi-source resource with an explicit
+requested/prepared revision boundary:
+
+```text
+proxy/source change
+    -> requested revision + dirty layer
+    -> one scheduled next-frame snapshot
+    -> consumed/in-flight request
+    -> adapter candidate preparation
+    -> guarded adapter + prepared-revision publication
+```
+
+`ConsumeUpdateRequest()` produces an immutable snapshot and marks that
+revision in flight. A current consumed revision may be completed through
+`CommitPreparedAdapterRevision()`, failed through `FailUpdateRequest()`, or
+returned to the queue through `RetryUpdateRequest()`. Commit-before-consume
+and stale commits are rejected; rejected candidate allocations are destroyed
+by default.
+
+Publication installs the adapter allocation and prepared revision before
+completion events run. The result returns the displaced allocation to the
+adapter owner for post-publication destruction. A reentrant source change may
+therefore request a newer revision without allowing stale completion to
+replace it. The previous prepared allocation and `IsGood()` remain usable
+while a replacement is pending or if replacement preparation fails.
+
+`Ready()` is specialized for this derived resource: it resolves when the
+generation requested at call time has been published, rather than delegating
+to a single-source object loader. Initial preparation failure rejects it.
+
+## Adapter commit example
+
+Consumed snapshots are explicit in-flight generations. An adapter either
+publishes the current candidate atomically, requeues retryable work, or
+records failure:
+
+```js
+const request = textureArray.ConsumeUpdateRequest();
+
+try {
+  const candidate = await adapter.PrepareTextureArray(request);
+  const result = textureArray.CommitPreparedAdapterRevision(
+    request.revision,
+    "webgpu",
+    candidate
+  );
+
+  // A rejected/stale candidate is destroyed by the commit method by default.
+  // The adapter owns disposal of a successfully displaced allocation.
+  result.displaced?.destroy();
+} catch (error) {
+  textureArray.FailUpdateRequest(request.revision, error, { retry: true });
+}
+
+await textureArray.Ready(); // the generation requested at call time
+```
+
+## Sources and topology
+
+Logical paths and resolved sources are independent. `SetLayerResource()`
+attaches a resolved or LOD-specific source without rewriting the logical
+requested path or persistence. `TouchLayer()` invalidates an in-place source
+revision. `HandleAdapterLoss()` drops an unusable adapter allocation and
+schedules a complete topology rebuild. Topology-changing snapshots set
+`topologyChanged: true` and report only valid current layer indices in
+`dirtyLayers`.
+
+## Related documentation
+
+- [Architecture and boundaries](../architecture.md)
+- [Texture CPU pipeline and LOD membership](texture-pipeline.md)

package/docs/reference/texture-pipeline.md

@@ -0,0 +1,53 @@
+# Texture CPU pipeline and LOD membership
+
+Status: Evolving  
+Scope: `@carbonenginejs/runtime-resource`  
+Audience: Users and integrators  
+Summary: Defines the `Tr2TexturePipeline` CPU-only step contract and `Tr2TextureLodManager` membership ownership.
+
+## Tr2TexturePipeline
+
+`Tr2TexturePipeline` is the Carbon texture-specific CPU bitmap pipeline, not a
+general resource prepare stage. `GetResourceDependencies()` returns the sorted
+unique paths required by load and channel-pack steps. `Execute()` resolves
+those inputs from an explicit `inputs` map/object, an async `load(path)`
+callback, or an injected `CjsResMan`, then returns a canonical plain
+`rgba8unorm` payload:
+
+```js
+import {
+  Tr2TexturePipeline,
+  Tr2TexturePipelineStepLoad,
+  Tr2TexturePipelineStepLimitSize
+} from "@carbonenginejs/runtime-resource";
+
+const load = new Tr2TexturePipelineStepLoad();
+load.path = "res:/texture/source.png";
+const limit = new Tr2TexturePipelineStepLimitSize();
+limit.maxWidth = 512;
+
+const pipeline = new Tr2TexturePipeline();
+pipeline.steps = [ load, limit ];
+const rgba = await pipeline.Execute(0, 0, { resMan });
+```
+
+The maintained runtime path currently accepts canonical `rgba8unorm` inputs.
+Load copies the source bitmap, limit-size repeatedly performs a 2x2 CPU
+downsample, pack builds logical RGBA channels from independent inputs, and
+Carbon's present compress step remains validation-only because the native
+method is itself a no-op. Unsupported step types fail explicitly.
+
+For the decoded-DDS fallback contract used by 2D texture inputs, see the
+[DDS notes in the format map](../formats/README.md#dds-decoded-fallback).
+
+## Tr2TextureLodManager
+
+`Tr2TextureLodManager` owns only ordered resource membership through
+`RegisterTexture()`, `UnregisterTexture()`, and `GetManagedTextures()`.
+Engine packages continue to own GPU allocations, upload accounting, device
+budgets, capability limits, and device-loss recovery.
+
+## Related documentation
+
+- [Texture arrays and update generations](texture-arrays.md)
+- [Format subpaths](../formats/README.md)

package/docs/roadmap.md

@@ -0,0 +1,104 @@
+# Roadmap
+
+Status: Evolving  
+Scope: `@carbonenginejs/runtime-resource`  
+Audience: Integrators and maintainers  
+Summary: Records approved future direction and open design questions; nothing on this page is implemented.
+
+Everything below is future work. Current behavior is documented in the
+[reference pages](reference/motherlode-cache.md); where this page and a
+reference page disagree, the reference page describes the shipped package.
+
+## Runtime manager follow-up
+
+The ResMan/MotherLode contract is complete for its current consumers. Future
+work should be driven by measured application needs rather than another
+resource preparation abstraction:
+
+- main-queue priority and starvation policy;
+- cancellation/abort propagation for work that has already started;
+- `WaitUrgent()` after real priority and bounded fairness;
+- queue-time and reader/format-time telemetry;
+- application-level default retention policy selection;
+- automatic resource/payload byte estimation and separate CPU/adapter
+  budgets;
+- browser-aware source behavior such as fetch response type selection;
+- purged-resource/device-loss recovery policy (backend device-loss recovery
+  belongs to the engine's realization operation).
+
+## Pre-adoption lifecycle API cleanup (approved, not implemented)
+
+No released consumer currently depends on the ccpwgl-compatible liveness
+names; the known ccpwgl format integrations are migration targets rather than
+a reason to preserve them. Before runtime-core or another public consumer
+adopts this contract, remove `KeepAlive()` and `KeepPayloadAlive()` instead
+of retaining or deprecating compatibility aliases.
+
+The public lifecycle should express caller intent directly:
+
+- `Ready()` obtains or reconstructs the CPU payload;
+- `AcquireLock()` returns a scoped hard-retention token;
+- `ReleasePayload()` explicitly drops the CPU payload; and
+- state queries remain pure.
+
+ResMan should update identity activity when a canonical resource is acquired
+and payload activity when it publishes or returns a ready payload. Those
+timestamps are cache-policy implementation details, not calls consumers
+should have to make. Cache admission and promotion must also be explicit
+manager operations: merely accessing a resource must not permanently move it
+from the byte-budget candidate set into an unbudgeted live set.
+
+Do not add `TouchIdentity()` or `TouchPayload()` to the initial public API
+unless a concrete soft-retention consumer appears. A consumer that needs a
+residency guarantee should acquire a lock; one that merely uses a resource
+should call `Ready()` and allow the configured cache policy to operate.
+
+Raw `Lock()` / `Unlock()` is easy to mis-pair across asynchronous success,
+failure, cancellation, and disposal. Prefer a JS-only acquired-lock API:
+
+```js
+const hold = resource.AcquireLock();
+try {
+  const payload = await resource.Ready();
+  await consume(payload);
+} finally {
+  hold.Release();
+}
+```
+
+The acquired token should add exactly one lock, capture the canonical key and
+ownership generation that received it, and release that exact lock at most
+once. `Release()` must be idempotent. If the original record has been
+deleted, replaced, purged, or rebound, releasing the stale token must not
+decrement a new owner's lock. Acquisition and release must never fetch,
+reconstruct, prepare, or release payload data themselves.
+
+The token is an async-safety replacement for exposing the existing raw lock
+count, not a new retention policy. For example, runtime-audio can hold
+source/PCM payload through decode and release the token once it owns the
+resulting WebAudio `AudioBuffer`; keeping the resource locked for the full
+playback or decoded-cache lifetime would unnecessarily retain both
+representations. Runtime-lifetime and group retention remain caller policy
+built from explicit tokens, not an implicit default on every loaded resource.
+
+## Open design questions
+
+- Should `Unload()` drop only adapter payloads by default, or CPU payloads
+  too?
+- Should there be explicit `UnloadAdapterResources()`, `UnloadPayload()`, and
+  `Purge()` phases?
+- Which format/resource-specific estimators should supply separate identity,
+  CPU-payload, and adapter byte weights without double-counting shared
+  buffers?
+- Should manually attached/dynamic resources default to locked, like ccpwgl's
+  manual shader resources use `doNotPurge`?
+- What explicit `Reload()`/reconstruction API should restore purged resources
+  without introducing surprising browser or network work?
+- A resource-level `Purge()`/`Reload()` vocabulary remains future policy
+  work, as does whether `Unload()` should release engine adapter resources
+  and optionally CPU payloads.
+
+## Related documentation
+
+- [MotherLode identity, cache, and retention](reference/motherlode-cache.md)
+- [Candidate-first atomic reload](reference/reload.md)

package/format-notices/gr2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 cppctamber / CarbonEngineJS contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/format-notices/gr2/NOTICE

@@ -0,0 +1,60 @@
+carbonenginejs/format-gr2
+=========================
+
+A pure-JavaScript reader for RAD Game Tools' Granny 3D (.gr2) file format.
+Contains no RAD/Granny code and does not link granny2.dll. Section decompression
+is reimplemented from clean-room / open reverse-engineering efforts, listed below.
+
+CarbonEngineJS-facing code is copyright cppctamber / CarbonEngineJS
+contributors. CarbonEngine source material, formats, class names, and schema
+semantics remain copyright their original CarbonEngine authors.
+Fenris Creations (CCP Games) source material, tools, assets, shader behavior,
+and EVE-related data remain copyright their original holders.
+
+Current repository license: MIT. See LICENSE.
+
+The former EUPL-derived BitKnit implementation was replaced on 2026-07-24 by
+an original clean-room implementation written solely from this package's
+published format specification (docs/formats/bitknit2.md); no EUPL-derived
+code remains.
+
+Provenance and legal requirements
+---------------------------------
+
+When this package copies, ports, translates, or derives from CarbonEngine,
+ccpwgl, Fenris Creations (CCP Games) / EVE assets or tools, RAD/Granny
+materials, or any third-party library, the relevant section below must record
+the upstream copyright holders, project/repository, file path, revision when
+known, license name, and required redistribution obligations. Behavioral
+references with no copied expression should be marked as references only.
+
+CarbonEngine and Fenris Creations (CCP Games) are mentioned for interoperability
+and provenance context. This package is not affiliated with or endorsed by CCP
+Games.
+
+Third-party algorithm provenance
+--------------------------------
+
+Oodle1 / Oodle0 section decompressor (src/codecs/oodle1.js)
+  Ported from the open Granny2 decompressors:
+    - nwn2mdk  "gr2_decompress"        (Boost Software License 1.0)
+    - arves100/opengr2  "oodle1.c"     (MPL-2.0)   https://github.com/arves100/opengr2
+  This is Granny's own legacy codec, not RAD's modern Oodle (Kraken/BitKnit families).
+
+BitKnit / BitKnit2 section decompressor (src/core/bitknit2.js)
+  Original CarbonEngineJS clean-room implementation (2026-07-24), written
+  solely from this package's published format specification
+  (docs/formats/bitknit2.md) by an isolated implementer, and validated
+  byte-exact against the EVE .gr2 corpus. It replaced a prior port of
+  neptuwunium/Knit (EUPL-1.2); no code from Knit, pybg3, ooz, or any other
+  BitKnit implementation remains. See THIRD-PARTY-NOTICES.md.
+
+Granny curve decompression (src/curves/**, optional; enabled via decompressCurves)
+  Adapted from cppctamber's granny extension for ccpwgl2 (src/core/reader/granny/curves).
+
+Container / relocation / type-tree reflection (src/container.js, src/reader.js)
+  Original to this project, derived from the on-disk Granny GRN format layout
+  (cross-referenced with the Granny SDK headers and the above projects' docs).
+
+Please retain this NOTICE, LICENSE, THIRD-PARTY-NOTICES.md, and the upstream
+licenses when redistributing.

package/format-notices/gr2/THIRD-PARTY-NOTICES.md

@@ -0,0 +1,93 @@
+# Third-party notices
+
+`format-gr2` is licensed under **MIT**. It contains no RAD/Granny proprietary
+code and does not link `granny2.dll`. The section decompressors are original
+or ported from permissively licensed open reverse-engineering work and must
+retain the notices and obligations listed below.
+
+Do not treat copied or ported prior work as CarbonEngineJS-original code. Each
+copied/ported/adapted component must list its upstream copyright holders,
+source project, path, revision when known, license, and redistribution
+requirements. Code used only as a behavioral reference should be marked as
+reference-only.
+
+---
+
+## Oodle1 / Oodle0 decompressor - `src/core/oodle1.js`
+
+**Boost Software License 1.0.** Ported from the Granny `gr2_decompress` implementation
+shipped in [Arbos/nwn2mdk](https://github.com/Arbos/nwn2mdk) (the decompressor is
+originally by *berenm* and is distributed under Boost 1.0, separate from nwn2mdk's
+Apache-2.0 format code). Cross-checked for correctness against
+[arves100/opengr2](https://github.com/arves100/opengr2) `oodle1.c` (MPL-2.0) - used as a
+verification reference only; no opengr2 code was copied, so MPL-2.0 does not apply.
+
+```
+Boost Software License - Version 1.0 - August 17th, 2003
+
+Permission is hereby granted, free of charge, to any person or organization
+obtaining a copy of the software and accompanying documentation covered by
+this license (the "Software") to use, reproduce, display, distribute, execute,
+and transmit the Software, and to prepare derivative works of the Software, and
+to permit third-parties to whom the Software is furnished to do so, all subject
+to the following:
+
+The copyright notices in the Software and this entire statement, including the
+above license grant, this restriction and the following disclaimer, must be
+included in all copies of the Software, in whole or in part, and all derivative
+works of the Software, unless such copies or derivative works are solely in the
+form of machine-executable object code generated by a source language processor.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
+SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
+FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
+DEALINGS IN THE SOFTWARE.
+```
+
+---
+
+## BitKnit / BitKnit2 decompressor - `src/core/bitknit2.js`
+
+**Original CarbonEngineJS code (MIT).** On 2026-07-24 the previous
+EUPL-derived port (transcribed from
+[neptuwunium/Knit](https://github.com/neptuwunium/Knit)
+`GrannyBitKnitCompression.cs`, EUPL-1.2) was replaced by a clean-room
+implementation produced through a documented two-party process: one party
+analyzed the format and published a facts-only decoding specification
+(`docs/formats/bitknit2.md`); a second, isolated party implemented the
+decoder solely from that specification with no access to Knit, pybg3, ooz,
+or any other BitKnit implementation. The result was validated byte-exact
+against 539 BitKnit2 streams extracted from the EVE `.gr2` corpus (section
+payloads and compressed pointer-fixup blocks) plus synthetic raw-quantum
+streams. No third-party code, EUPL-derived or otherwise, remains in this
+file. BitKnit is a RAD Game Tools codec; the specification records on-disk
+format facts only.
+
+---
+
+## Granny animation-curve decompression - `src/core/curves.js`
+
+Authored by **cppctamber** as part of ccpwgl2 (`src/core/reader/granny/curves`), the
+same author/owner as this library; included here under this project's MIT
+license.
+
+## Tangent-frame shader math - `src/core/tangents.js`
+
+The packed tangent-frame decode/encode math is derived from Fenris Creations
+(formerly CCP / CCP Games) EVE/Carbon shader behavior for packed tangent frames.
+This package contains a JavaScript implementation of the tangent-frame math and
+does not include copied shader source.
+
+If shader source is later copied, ported, or translated directly, update this
+notice with the exact upstream repository, file path, revision, copyright
+holders, license text or required notice location, and redistribution
+obligations before committing that work.
+
+## Container, relocation, type-tree reflection, emitter
+
+Original to this project (cppctamber / carbonenginejs). Included here under
+this project's MIT license. Derived from the public on-disk Granny
+GRN format layout and the Granny SDK header type definitions.

package/package.json

@@ -1,51 +1,52 @@
-{
-  "name": "@carbonenginejs/runtime-resource",
-  "version": "0.7.0",
-  "description": "CarbonEngineJS resource lifecycle, cache, source, and object loading contracts.",
-  "type": "module",
-  "exports": {
-    ".": "./dist/index.js",
-    "./formats": "./dist/formats/index.js",
-    "./formats/black": "./dist/formats/black/index.js",
-    "./formats/black/schema": "./dist/formats/black/core/blackSchema.js",
-    "./formats/black/enums": "./dist/formats/black/core/blackEnums.js",
-    "./formats/black/version": "./dist/formats/black/core/blackVersion.js",
-    "./formats/bnk": "./dist/formats/bnk/index.js",
-    "./formats/cmf": "./dist/formats/cmf/index.js",
-    "./formats/dds": "./dist/formats/dds/index.js",
-    "./formats/fbx": "./dist/formats/fbx/index.js",
-    "./formats/flac": "./dist/formats/flac/index.js",
-    "./formats/gif": "./dist/formats/gif/index.js",
-    "./formats/gltf": "./dist/formats/gltf/index.js",
-    "./formats/jpeg": "./dist/formats/jpeg/index.js",
-    "./formats/mp3": "./dist/formats/mp3/index.js",
-    "./formats/mp4": "./dist/formats/mp4/index.js",
-    "./formats/obj": "./dist/formats/obj/index.js",
-    "./formats/ogg": "./dist/formats/ogg/index.js",
-    "./formats/png": "./dist/formats/png/index.js",
-    "./formats/red": "./dist/formats/red/index.js",
-    "./formats/red/schema": "./dist/formats/red/core/blackDefinitions.js",
-    "./formats/stl": "./dist/formats/stl/index.js",
-    "./formats/tga": "./dist/formats/tga/index.js",
-    "./formats/wav": "./dist/formats/wav/index.js",
-    "./formats/webm": "./dist/formats/webm/index.js",
-    "./formats/webp": "./dist/formats/webp/index.js",
-    "./formats/wem": "./dist/formats/wem/index.js",
-    "./formats/yaml": "./dist/formats/yaml/index.js"
-  },
-  "sideEffects": false,
-  "engines": {
-    "node": ">=18"
-  },
-  "dependencies": {
-    "@carbonenginejs/core-math": "^0.1.3",
+{
+  "name": "@carbonenginejs/runtime-resource",
+  "version": "0.9.0",
+  "description": "CarbonEngineJS resource lifecycle, cache, source, and object loading contracts.",
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.js",
+    "./formats": "./dist/formats/index.js",
+    "./formats/black": "./dist/formats/black/index.js",
+    "./formats/black/schema": "./dist/formats/black/core/blackSchema.js",
+    "./formats/black/enums": "./dist/formats/black/core/blackEnums.js",
+    "./formats/black/version": "./dist/formats/black/core/blackVersion.js",
+    "./formats/bnk": "./dist/formats/bnk/index.js",
+    "./formats/cmf": "./dist/formats/cmf/index.js",
+    "./formats/dds": "./dist/formats/dds/index.js",
+    "./formats/fbx": "./dist/formats/fbx/index.js",
+    "./formats/flac": "./dist/formats/flac/index.js",
+    "./formats/gif": "./dist/formats/gif/index.js",
+    "./formats/gltf": "./dist/formats/gltf/index.js",
+    "./formats/gr2": "./dist/formats/gr2/index.js",
+    "./formats/jpeg": "./dist/formats/jpeg/index.js",
+    "./formats/mp3": "./dist/formats/mp3/index.js",
+    "./formats/mp4": "./dist/formats/mp4/index.js",
+    "./formats/obj": "./dist/formats/obj/index.js",
+    "./formats/ogg": "./dist/formats/ogg/index.js",
+    "./formats/png": "./dist/formats/png/index.js",
+    "./formats/red": "./dist/formats/red/index.js",
+    "./formats/red/schema": "./dist/formats/red/core/blackDefinitions.js",
+    "./formats/stl": "./dist/formats/stl/index.js",
+    "./formats/tga": "./dist/formats/tga/index.js",
+    "./formats/wav": "./dist/formats/wav/index.js",
+    "./formats/webm": "./dist/formats/webm/index.js",
+    "./formats/webp": "./dist/formats/webp/index.js",
+    "./formats/wem": "./dist/formats/wem/index.js",
+    "./formats/yaml": "./dist/formats/yaml/index.js"
+  },
+  "sideEffects": false,
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@carbonenginejs/core-math": "^0.1.5",
     "@carbonenginejs/core-types": "^0.12.0",
-    "@carbonenginejs/runtime-const": "^0.1.0",
-    "meshoptimizer": "^1.2.0",
-    "yaml": "^2.4.0"
-  },
-  "license": "MIT",
-  "publishConfig": {
-    "access": "public"
-  }
-}
+    "@carbonenginejs/runtime-const": "^0.1.0",
+    "meshoptimizer": "^1.2.0",
+    "yaml": "^2.4.0"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  }
+}