@carbonenginejs/runtime-resource 0.1.0

package/FORMAT-PROVENANCE.md

@@ -0,0 +1,135 @@
+# Format ownership and fork provenance
+
+On 2026-07-13, the non-shader runtime format implementations below were copied
+once into `runtime-resource`. Their standalone repositories remain frozen with
+their existing APIs and names; they are not upstreams for the runtime copies.
+
+Copied paths were `src/` and the behavioral `test/` corpus. Package publishing
+scripts and CLIs were not copied. Exact donor license and notice files are kept
+under `format-notices/<format>/`.
+
+| Legacy package | Source revision/state | Runtime class | Runtime import |
+|---|---|---|---|
+| `format-black` | `9fcaaff9e5f28c90b628d8a10b7c79aff7913a90` | `CjsBlackFormat` | `@carbonenginejs/runtime-resource/formats/black` |
+| `format-cmf` | unborn working-tree snapshot | `CjsCmfFormat` | `@carbonenginejs/runtime-resource/formats/cmf` |
+| `format-dds` | `66fa149cd826e1114ad0be84479f89dee753ed76` | `CjsDdsFormat` | `@carbonenginejs/runtime-resource/formats/dds` |
+| `format-fbx` | `8d0fcc2fe44c8096b35e360a903bff30b49eb592` | `CjsFbxFormat` | `@carbonenginejs/runtime-resource/formats/fbx` |
+| `format-flac` | unborn working-tree snapshot | `CjsFlacFormat` | `@carbonenginejs/runtime-resource/formats/flac` |
+| `format-gif` | `5d831c5c0533a9579682f776274574289a520899` | `CjsGifFormat` | `@carbonenginejs/runtime-resource/formats/gif` |
+| `format-gltf` | `d0dadf920828bceec987c2a5fa1f161f81db28aa` | `CjsGltfFormat` | `@carbonenginejs/runtime-resource/formats/gltf` |
+| `format-jpeg` | `bed2253ea979bba27812420fa897987d82a91793` | `CjsJpegFormat` | `@carbonenginejs/runtime-resource/formats/jpeg` |
+| `format-mp3` | unborn working-tree snapshot | `CjsMp3Format` | `@carbonenginejs/runtime-resource/formats/mp3` |
+| `format-mp4` | `cffc5a57b115a99ed9e0947a6b9d3390ffc3581c` | `CjsMp4Format` | `@carbonenginejs/runtime-resource/formats/mp4` |
+| `format-obj` | `e5d3f9a1520c7855bd5b6edc1e2304a7b4e18176` | `CjsObjFormat` | `@carbonenginejs/runtime-resource/formats/obj` |
+| `format-ogg` | unborn working-tree snapshot | `CjsOggFormat` | `@carbonenginejs/runtime-resource/formats/ogg` |
+| `format-png` | `04dbb7c0f289043c3c32d9141ec3ef74aeeb1c43` | `CjsPngFormat` | `@carbonenginejs/runtime-resource/formats/png` |
+| `format-red` | `98beab6988111418d6e09827b92d27e08da4c05b` | `CjsRedFormat` | `@carbonenginejs/runtime-resource/formats/red` |
+| `format-stl` | `4858f9a37bf140a3c544fa30a13a6fcce015247b` | `CjsStlFormat` | `@carbonenginejs/runtime-resource/formats/stl` |
+| `format-tga` | `b0f9df263727057537b2279322e8cd088f366179` | `CjsTgaFormat` | `@carbonenginejs/runtime-resource/formats/tga` |
+| `format-wav` | unborn working-tree snapshot | `CjsWavFormat` | `@carbonenginejs/runtime-resource/formats/wav` |
+| `format-webm` | `459203ac293d0d53fff0e43494b7e47d8d4c92bd` | `CjsWebmFormat` | `@carbonenginejs/runtime-resource/formats/webm` |
+| `format-webp` | `19155e9cc7ae05845c23a3c259d3a586569eba40` | `CjsWebpFormat` | `@carbonenginejs/runtime-resource/formats/webp` |
+| `format-yaml` | `3d7e1d1cf9b7a936283d6050efe43a0a9fadb6a4` | `CjsYamlFormat` | `@carbonenginejs/runtime-resource/formats/yaml` |
+
+The unborn donors had no commit-addressable `HEAD`; this document deliberately
+records them as working-tree snapshots rather than inventing a revision. Their
+copied runtime files are the deterministic retained snapshot.
+
+## Black definition snapshot
+
+The Black and Red readers use the package-owned generated definition snapshot
+at `src/formats/black/core/black-schema-v1-2026-07-11.json`. It was copied from
+`format-carbon` revision `d2a3c67cf3d46e8ba78ca19e66558d868178ec24`
+with SHA-256
+`008ECB29E670EFC678B471A6EFF099600A29C2907912FC42B854995904604691`.
+
+This retained generated artifact keeps the published readers deterministic and
+browser-safe without a runtime dependency on a sibling checkout or an
+unpublished `format-carbon` export. `format-carbon` remains the build-time
+authority for future schema regeneration; an updated snapshot must record its
+new source revision and digest here.
+
+## Native additions
+
+Formats below were authored directly in `runtime-resource` and have no legacy
+donor package. Their `format-notices/<format>/` entries record third-party
+format attribution rather than fork provenance.
+
+| Format | Runtime class | Runtime import | Notes |
+|---|---|---|---|
+| Wwise soundbank (`.bnk`) | `CjsBnkFormat` | `@carbonenginejs/runtime-resource/formats/bnk` | Original code; chunk layout from public community documentation (ww2ogg, vgmstream, wwiser), no code copied. Also carries the SoundbanksInfo JSON helpers (`parseSoundbanksInfo`, `buildSoundbanksCatalog`, `joinSoundbanksInfo`) and `wwiseIdFromName` (FNV-1 32 of the lowercased name, verified against EVE bank/language ids). |
+| Wwise media (`.wem`) | `CjsWemFormat` | `@carbonenginejs/runtime-resource/formats/wem` | Original code; container/codec-tag behavior from public community documentation (ww2ogg, vgmstream, wwiser), no code copied. Includes a Wwise-Vorbis→Ogg repacker (`emit: "ogg"`), an original reimplementation of the ww2ogg algorithm with inline granule computation (no revorb pass needed). |
+
+## Post-fork additions inside copied formats
+
+- `formats/cmf` gained a **binary CMF v1 writer** (2026-07-15,
+  `src/formats/cmf/core/writer.js`, `CjsCmfFormat.write`/`writeAsync` and
+  `Write`/`WriteAsync`): original code implementing CarbonEngine's
+  `cmf::BuildFile` behavior — tagged self-relative span flattening with leaf
+  chunk dedup, BufferView→section remapping in first-encounter order,
+  meshoptimizer vertex/index compression (index compression canonicalizes
+  triangle rotation, matching the engine's own writer test expectations), and
+  the post-crc32 file checksum. Verified by write→read roundtrips against the
+  runtime reader; `E:\carbonengine\mesh\{include,src}\cmf` was the behavioral
+  reference, no code copied. `writeShared`/`writeSharedAsync` plus
+  `core/pack.js` (channel interleaving, index packing, unique buffer-index
+  assignment) serialize shared geometry directly, enabling GR2/OBJ/glTF→CMF —
+  verified against real EVE `.gr2` models fetched via
+  `@carbonenginejs/tool-index` (positions exact, triangles equivalent).
+- `formats/cmf` also gained the **GR2 skeleton/animation converter**
+  (2026-07-15, `src/formats/cmf/core/gr2Anim.js`, applied automatically by
+  `writeShared`): GR2-shaped skeletons (root list or `models[].skeleton`)
+  convert to CMF bones/parents/rest transforms with inverse binds rebuilt
+  from the rest hierarchy; decoded Granny curves convert to CMF Step/Linear
+  channels — degree ≤ 1 exactly, degree 2 via adaptive de Boor resampling
+  with discontinuities snapped to one float32 ULP. Consumes only decoded
+  `{knots, controls}` data so the MIT runtime stays independent of the GR2
+  package. Validated on EVE ships (cde3_t3, gde3_t3, cfaux1_t1, mfaux1_t1:
+  3,377 channels ≤ 8.3e-4 positional / ≤ 0.14° rotational vs the GR2 runtime
+  sampler; 9 Granny curve formats) and characters (basicfemale: 132-bone
+  skeleton, exact skin weights).
+- `formats/ogg` gained a pure-JS **Ogg Vorbis PCM decoder** (2026-07-15,
+  `src/formats/ogg/core/{vorbis.js,imdct.js}`, `emit: "pcm"`/`"audio"`):
+  original code implementing the Vorbis I specification (floor 1, residues
+  0/1/2, square-polar coupling, FFT-based IMDCT, windowed overlap-add).
+  stb_vorbis (public domain) was consulted as a behavioral reference and is
+  the source of the spec's floor1 `inverse_db_table` constants; no licensed
+  code was copied. Validated bit-comparable to ffmpeg (max diff ~3e-8) and
+  vgmstream (±1 int16 LSB) across the EVE Vorbis corpus.
+
+## Wem packed-codebook snapshot
+
+The wem Ogg repacker ships a package-owned copy of the aoTuV 6.03 packed
+Vorbis codebook library at
+`src/formats/wem/core/packedCodebooksAotuv603.js` (base64 module). It was
+copied byte-identically from `packed_codebooks_aoTuV_603.bin` in the ww2ogg
+distribution (`github.com/hcs64/ww2ogg`), 74,387 bytes, SHA-256
+`00a93eab267d281401b1efd54e888a2e183299b9e6c446c48d09f701a89d9d27`, retrieved
+2026-07-15. The data is BSD-licensed (Xiph.org Foundation, Adam Gashlin);
+attribution and the full license terms are recorded in
+`format-notices/wem/NOTICE` and `format-notices/wem/LICENSE`. An updated
+snapshot must record its new source and digest here.
+
+## Deliberately not copied
+
+- `format-gr2` is the intended runtime-resource owner target, but its current
+  BitKnit-derived implementation is EUPL-1.2. It remains separate and active
+  until that code is replaced or an explicit distribution-license decision is
+  made. It has not been deprecated or relabeled as MIT.
+- `format-carbon` remains the schema emitter/generator and build-time schema
+  authority. Black and Red consume its published Black definitions.
+- `format-dxbc`, `format-hlsl`, `format-webgl`, and `format-webgpu` are active
+  shader work and were not copied, annotated, or otherwise modified by this
+  migration.
+
+## Typed-array ownership adjustments
+
+The runtime copies preserve caller byte objects by reference. During the fork,
+three avoidable source-buffer copies were changed to views:
+
+- CMF compressed sections use `Uint8Array.subarray`.
+- glTF GLB chunks use `Uint8Array.subarray`.
+- FBX raw binary property payloads use `Uint8Array.subarray`.
+
+Decoder output buffers and GIF per-frame snapshots still allocate because those
+values have independent semantic identity.

package/LICENSE

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

@@ -0,0 +1,29 @@
+carbonenginejs/runtime-resource
+================================
+
+Copyright (c) 2026 CarbonEngineJS contributors.
+
+This package owns CarbonEngineJS resource lifecycle, format selection, and the
+non-shader format implementations listed under `format-notices/`.
+
+CarbonEngine source material, format names, 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. These names are used for
+interoperability and provenance context. This project is not affiliated with
+or endorsed by CCP Games.
+
+The copied format implementations retain their original MIT license and NOTICE
+files under `format-notices/<format>/`. Those notices include third-party
+dependency and behavioral-reference attribution, including meshoptimizer,
+yaml, and black-reader-js.
+
+The bundled Black definition JSON is a generated CarbonEngineJS schema artifact
+copied from `format-carbon` revision
+`d2a3c67cf3d46e8ba78ca19e66558d868178ec24`. Its exact digest and retention
+purpose are recorded in `FORMAT-PROVENANCE.md`; no CarbonEngine source file or
+game asset is embedded in that generated definition snapshot.
+
+The EUPL-1.2 `format-gr2` implementation is deliberately not included. GR2
+ownership migration remains deferred until its EUPL-derived BitKnit boundary
+is replaced or an explicit distribution-license decision is made.

package/README.md

@@ -0,0 +1,241 @@
+# @carbonenginejs/runtime-resource
+
+CarbonEngineJS resource lifecycle, cache, format selection, source, and object
+loading contracts.
+
+This package owns the GPU-free resource layer:
+
+- `CjsResource` state and Carbon-style resource methods.
+- `CjsTextureArrayRes` and `CjsTextureParameterProxy` for material-facing,
+  frame-coalesced texture-array inputs without changing ordinary texture
+  parameter behavior.
+- `CjsMotherLode` cache lookup/insert/delete/stats.
+- `CjsResMan` semantic resource construction, registered-format selection,
+  concurrency-limited source loading, staged prepare queues, layered
+  source/read/resource deduplication, object loader dispatch, and prefetch.
+- Raw `CjsEventEmitter` from `core-types/model` for manager/runtime events
+  without requiring `CjsModel` inheritance. External listeners unregister
+  directly with `OffEvent`; listener scopes, owner-side `ListenTo` helpers,
+  and a separate resource notification layer are not part of the contract.
+- Path normalization and extension helpers.
+- Source adapters for memory and `fetch`.
+- Plain reader/converter payload objects with focused shared validators.
+- Canonical Carbon resource classes that validate and hold CPU payloads
+  privately:
+  `TriTextureRes`, `TriGeometryRes`, `Tr2EffectRes`, `Tr2ImageRes`,
+  `TriGrannyRes`, `Tr2GrannyStateRes`, and `Tr2LightProfileRes`.
+- Opaque engine-owned subobject slots for backend adapters.
+- Format policy, format class contracts, and load/prepare state mapping stay
+  inside this package's implementation and public API rather than external
+  workspace notes.
+- Non-shader format implementations are owned as explicit tree-shakeable
+  subpaths under `@carbonenginejs/runtime-resource/formats/<name>`.
+
+It intentionally does not own WebGL/WebGPU realization. Engine packages should adapt prepared resources into backend objects.
+
+Authoring source is decorated JavaScript. Published/consumer output is built ESM in `npm/dist`.
+
+## Package relationships
+
+- `runtime-core` may configure and expose a `CjsResMan`, but does not own its
+  implementation.
+- `runtime-trinity` and `runtime-sof` may request GPU-free objects and resources
+  without selecting an engine.
+- `engine-webgpu` and future WebGL engines consume loaded resources and own all
+  backend allocations, preparation, replacement, and destruction.
+
+Concrete formats are not imported or registered by the package root:
+
+```js
+import { CjsResMan } from "@carbonenginejs/runtime-resource";
+import { CjsMp4Format } from "@carbonenginejs/runtime-resource/formats/mp4";
+
+const resMan = new CjsResMan().Register({
+  source,
+  formats: [ CjsMp4Format ]
+});
+
+const resource = resMan.GetResource("res:/video/intro.mp4");
+const video = await resource.Ready();
+```
+
+Formats return plain payload objects. Semantic resource classes apply them
+through `SetPayload()`, validate their own required fields, and throw
+`CJS_RESOURCE_PAYLOAD_INVALID` before replacing a previously valid payload.
+`GetPayload()`, `HasPayload()`, and `ReleasePayload()` manage transient CPU
+retention without introducing a parallel DTO class hierarchy.
+
+## Queued load and staged prepare
+
+`GetObject()`, `LoadObject()`, and resource `Ready()` use two manager-owned
+queues:
+
+```text
+BACKGROUND: deduplicated source load, limited by maxConcurrentLoads
+MAIN:       read -> configured prepare stages -> resource publication
+```
+
+Each main-queue stage is a separate item. `maxPrepareTime` is a per-pump budget
+in seconds, and `maxPrepareItemsPerTick` can add an item-count limit. The
+default scheduler keeps promise-based calls working; a `CjsLibrary` or direct
+caller can provide its frame scheduler and default build behavior:
+
+```js
+const resMan = new CjsResMan({
+  source,
+  maxConcurrentLoads: 8,
+  maxPrepareTime: 0.005,
+  queueScheduler: callback => requestAnimationFrame(callback),
+  preparePipelines: {
+    cmf_test: {
+      default: true,
+      stages: [
+        {
+          name: "convert",
+          prepare: (payload, context) => convertToCmf(payload, context)
+        }
+      ]
+    }
+  }
+});
+
+await resMan.FetchResource("res:/model/ship.gr2", {
+  requirement: "geometry",
+  preparePipeline: "cmf_test"
+});
+```
+
+The library chooses the named pipeline from registered behavior and detected
+capabilities. `CjsResMan` executes that request; it does not inspect WebGL,
+WebGPU, texture, geometry, or codec support to select one. A request may
+override the default with `preparePipeline` or append direct `prepareStages`.
+
+Blue-compatible queue controls are exposed directly on `CjsResMan`:
+`AddToQueue`, `CancelFromQueue`, `GetNextIdForQueue`,
+`PumpMainThreadQueue`, `PauseQueue`, `ResumeQueue`, `GetPendingLoads`, and
+`GetPendingPrepares`. `Update()`/`Tick()` pump work, while `Wait()` is the
+method-level queue fence; no separate fence object is required.
+
+Format classes own input extensions. Resource classes are registered by a
+semantic requirement, never by file extension:
+
+```js
+const resMan = new CjsResMan().Register({
+  source,
+  formats: [ CjsDdsFormat, CjsPngFormat ],
+  resourceTypes: [ TriTextureRes, Tr2ImageRes ]
+});
+
+const texture = resMan.GetResource("res:/image/ship.png", {
+  requirement: "texture",
+  emit: "image"
+});
+const image = resMan.GetResource("res:/image/ship.png", {
+  requirement: "image",
+  emit: "image"
+});
+```
+
+Those are distinct resource identities but share the normalized source-byte
+operation. The manager does not expose an extension-to-resource compatibility
+registry.
+
+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.
+
+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
+```
+
+`SetLayerResource()` attaches a resolved source without rewriting the logical
+requested path. `TouchLayer()` invalidates an in-place source revision.
+`RetryUpdateRequest()` restores consumed work, and `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`.
+
+## Development
+
+Install dependencies and run the non-interactive baseline checks from the
+repository root:
+
+```sh
+npm install
+npm run lint
+npm run check
+npm test
+```
+
+`npm run check` builds the consumer package and proves that decorator metadata
+matches between authoring source and built output. `npm test` additionally runs
+the complete GPU-free unit suite; it requires no private assets, credentials,
+network access, browser, or GPU after dependencies are installed.
+
+See [Runtime Resource Lifecycle](resource-lifecycle.md) for state, retention,
+and texture-array generation contracts. See
+[Format ownership and fork provenance](FORMAT-PROVENANCE.md) for copied-reader
+ownership, licenses, exclusions, and the deferred GR2 migration. Both documents
+ship with the published package.
+
+## Provenance
+
+CarbonEngine and Fenris Creations (CCP Games) are named for interoperability
+and provenance context. This package contains CarbonEngineJS original resource
+infrastructure, CarbonEngine-shaped resource ports, and maintained copies of
+the non-shader readers identified in `FORMAT-PROVENANCE.md`. It does not copy
+Fenris Creations game assets, proprietary documentation, or shader source.
+CarbonEngine and historical JavaScript implementations were used as the
+behavioral references described in the package notices.
+
+This project is not affiliated with, endorsed by, or sponsored by CCP Games or
+CCP ehf. EVE Online and related marks remain the property of their respective
+owners.

package/dist/CjsMotherLode.js

@@ -0,0 +1,56 @@
+import { normalizeResourcePath } from './resourcePath.js';
+
+class CjsMotherLode {
+  #resources = new Map();
+  Lookup(path, variant = "") {
+    return this.#resources.get(GetCacheKey(path, variant)) || null;
+  }
+  Insert(resource, path = resource?.GetPath?.() ?? resource?.path, variant = "") {
+    const key = GetCacheKey(path, variant);
+    this.#resources.set(key, resource);
+    return resource;
+  }
+  Delete(path, variant = "") {
+    return this.#resources.delete(GetCacheKey(path, variant));
+  }
+  DeleteAll(path) {
+    const normalizedPath = normalizeResourcePath(path);
+    if (!normalizedPath) throw new TypeError("CjsMotherLode requires a resource path.");
+    const prefix = `${normalizedPath}\u0000`;
+    let deleted = false;
+    for (const key of this.#resources.keys()) {
+      if (key === normalizedPath || key.startsWith(prefix)) {
+        deleted = this.#resources.delete(key) || deleted;
+      }
+    }
+    return deleted;
+  }
+  Clear() {
+    this.#resources.clear();
+    return this;
+  }
+  Has(path, variant = "") {
+    return this.#resources.has(GetCacheKey(path, variant));
+  }
+  GetCount() {
+    return this.#resources.size;
+  }
+  GetStats() {
+    return Object.freeze({
+      count: this.#resources.size,
+      paths: Object.freeze([...new Set([...this.#resources.values()].map(resource => resource?.GetPath?.() ?? resource?.path ?? ""))].filter(Boolean))
+    });
+  }
+  Entries() {
+    return this.#resources.entries();
+  }
+}
+function GetCacheKey(path, variant = "") {
+  const normalizedPath = normalizeResourcePath(path);
+  if (!normalizedPath) throw new TypeError("CjsMotherLode requires a resource path.");
+  const normalizedVariant = variant === null || variant === undefined ? "" : String(variant);
+  return normalizedVariant ? `${normalizedPath}\u0000${normalizedVariant}` : normalizedPath;
+}
+
+export { CjsMotherLode };
+//# sourceMappingURL=CjsMotherLode.js.map

package/dist/CjsMotherLode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"CjsMotherLode.js","sources":["../../src/CjsMotherLode.js"],"sourcesContent":["import { normalizeResourcePath } from \"./resourcePath.js\";\n\nexport class CjsMotherLode\n{\n  #resources = new Map();\n\n  Lookup(path, variant = \"\") {\n    return this.#resources.get(GetCacheKey(path, variant)) || null;\n  }\n\n  Insert(resource, path = resource?.GetPath?.() ?? resource?.path, variant = \"\") {\n    const key = GetCacheKey(path, variant);\n    this.#resources.set(key, resource);\n    return resource;\n  }\n\n  Delete(path, variant = \"\") {\n    return this.#resources.delete(GetCacheKey(path, variant));\n  }\n\n  DeleteAll(path) {\n    const normalizedPath = normalizeResourcePath(path);\n    if (!normalizedPath) throw new TypeError(\"CjsMotherLode requires a resource path.\");\n    const prefix = `${normalizedPath}\\u0000`;\n    let deleted = false;\n    for (const key of this.#resources.keys())\n    {\n      if (key === normalizedPath || key.startsWith(prefix))\n      {\n        deleted = this.#resources.delete(key) || deleted;\n      }\n    }\n    return deleted;\n  }\n\n  Clear() {\n    this.#resources.clear();\n    return this;\n  }\n\n  Has(path, variant = \"\") {\n    return this.#resources.has(GetCacheKey(path, variant));\n  }\n\n  GetCount() {\n    return this.#resources.size;\n  }\n\n  GetStats() {\n    return Object.freeze({\n      count: this.#resources.size,\n      paths: Object.freeze([ ...new Set(\n        [ ...this.#resources.values() ].map(resource => resource?.GetPath?.() ?? resource?.path ?? \"\")\n      ) ].filter(Boolean))\n    });\n  }\n\n  Entries() {\n    return this.#resources.entries();\n  }\n}\n\nfunction GetCacheKey(path, variant = \"\")\n{\n  const normalizedPath = normalizeResourcePath(path);\n  if (!normalizedPath) throw new TypeError(\"CjsMotherLode requires a resource path.\");\n  const normalizedVariant = variant === null || variant === undefined ? \"\" : String(variant);\n  return normalizedVariant ? `${normalizedPath}\\u0000${normalizedVariant}` : normalizedPath;\n}\n"],"names":["CjsMotherLode","Map","Lookup","path","variant","get","GetCacheKey","Insert","resource","GetPath","key","set","Delete","delete","DeleteAll","normalizedPath","normalizeResourcePath","TypeError","prefix","deleted","keys","startsWith","Clear","clear","Has","has","GetCount","size","GetStats","Object","freeze","count","paths","Set","values","map","filter","Boolean","Entries","entries","normalizedVariant","undefined","String"],"mappings":"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"}