@carbonenginejs/runtime-trinity 0.4.0

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,20 @@
+@carbonenginejs/runtime-trinity
+================================
+
+Copyright (c) 2026 CarbonEngineJS contributors.
+
+This package contains a JavaScript implementation of CarbonEngine Trinity and
+EVE object-graph classes. Current coverage includes controllers, curves, EVE
+scene objects and attachments, particles, post-process descriptions, render
+jobs, shader and effect graph data, and Trinity core and UI descriptions.
+
+CarbonEngine and Fenris Creations (CCP Games) names, formats, class names, and
+class semantics remain the property of their respective owners. These names are
+used for interoperability and provenance context. Ported source files identify
+their relevant CarbonEngine source paths in file-level provenance comments.
+
+This project is not affiliated with, endorsed by, or sponsored by CCP Games or
+CCP ehf. "EVE Online" and related marks are the property of their respective
+owners. No game assets are redistributed in this package.
+
+License: MIT. See LICENSE.

package/README.md

@@ -0,0 +1,130 @@
+# @carbonenginejs/runtime-trinity
+
+Faithful CarbonEngine Trinity/Eve scene-graph model (the serializable Trinity
+Graph) and visual resource classes. Ports Tr2*/Eve* 1:1 from CarbonEngine.
+GPU-free.
+
+Part of the CarbonEngineJS runtime/engine tier. GPU-free JavaScript source,
+decorated for CarbonEngineJS schema metadata.
+
+## Status
+
+Active Carbon-faithful ports cover generated schema classes plus handwritten
+controller, curve, Eve, particle, shader-model, and utility behavior. Generated
+files are refreshed from the installed `format-carbon` metadata with:
+
+```sh
+npm run generate
+```
+
+This runtime owns serializable CPU-side state and behavior. Geometry, texture,
+and effect resources are supplied by resource runtimes; WebGPU/WebGL device,
+upload, binding, and destruction lifecycles belong to renderer runtimes.
+
+## WebGPU Main semantic extraction
+
+Two GPU-free helpers expose the proven runtime values needed by the first
+bounded Eve space-object Main binding profile:
+
+- `extractTr2EffectConstantValues(effect, reflectedConstants)` reads only the
+  requested reflected float constants across `parameters` and
+  `constParameters`. Dynamic parameters use `CopyValueToEffect`, preserving
+  rerouted values and sRGB-to-linear conversion. Missing, duplicate, malformed,
+  array, resource-like, or unsupported values fail closed.
+- `createEveSpaceObjectMainPerObjectValues({ object, shared, shipData,
+  vsOverrides, psOverrides })` maps `EveSpaceObject2` transform aliases,
+  trustworthy clip values, `EveSpacePerObjectData` fields/SH alias, and custom
+  masks into frozen plain `perObjectVS`/`perObjectPS` values.
+
+The per-object precedence is object-derived values, then explicitly supplied
+shared data, then VS/PS overrides. `shipData` is always required because no
+source-proven builder currently exists. Ellipsoid `w`, screen size, morph/bone
+offsets, impact fields, and similar optional values are copied only when the
+shared data or overrides supply them; they are never guessed.
+
+There is deliberately no per-frame scene builder yet. Previous matrices,
+shadow state, projection conventions, gamma/mip policy, frame/jitter values,
+resolution, and other renderer-owned state are not completely represented by
+the Trinity scene graph. The active renderer must provide the complete
+`perFrameVS` and `perFramePS` semantic objects before an engine serializer is
+called.
+
+Baseline checks:
+
+```sh
+npm run generate
+npm run build:npm
+npm test
+```
+
+## Graph ownership and GPU realization
+
+Carbon class ownership follows graph fidelity, not graphics terminology.
+`TriDevice`, `TriRenderJob`, render steps, render contexts, targets, buffers,
+effects, shaders and presentation records remain canonical Trinity classes.
+They describe Carbon object graphs and must be registerable, hydratable,
+inspectable and serializable without a canvas or GPU backend.
+
+Those classes do not own live GPU objects. WebGPU and WebGL engines separately
+own resource realization, context/device loss, synchronization, presentation,
+uploads, pipelines/programs, bindings, command execution and destruction.
+Backend objects must stay outside persisted schema fields, normally in
+engine-owned associations.
+
+We deliberately do not insert a `runtime-device` package between Trinity and
+the engines. WebGPU and WebGL have materially different lifecycles; a shared
+device lifecycle would either leak backend concepts or become a misleading
+lowest-common-denominator abstraction. Applications or `runtime-core` may
+select and inject an engine directly. A separate shared contract should only be
+introduced after two real engines demonstrate a stable common seam that is
+larger than structural capability checks.
+
+This keeps the package graph small and avoids constructor duplication,
+cross-package enum ownership, import-order registration, partial inheritance
+families, and generator exclusions for classes that are still graph data.
+
+## Render-job execution contract
+
+`TriRenderJob` and `Tr2RenderJobs` own Carbon's backend-neutral execution
+semantics: ordered step snapshots, `RJ_IN_PROGRESS` cursor persistence, nested
+job result mapping, recurring/once/chained scheduling, and target/depth stack
+validation and unwind. `TriRenderJob` exposes its status vocabulary as class
+statics; `TriRenderStep` does the same for step results.
+
+`Run(realTime, simTime, executor)` accepts a duck-typed executor/context. Trinity
+stores no generic RHI object and defines no `CjsRenderGraphExecutor` helper.
+WebGL may execute a step immediately; WebGPU may plan pass boundaries and encode
+commands, but both must preserve the observable order and yield boundary.
+Nested jobs receive the same executor identity.
+
+The default `Tr2RenderContext` is only a GPU-free intent stack and diagnostic
+surface. Live contexts, targets, encoders, command buffers, handles,
+presentation, and device-loss state remain engine-owned. JS execution
+intentionally hardens Carbon's exception and leaked-stack paths with
+deterministic `finally` cleanup and diagnostics.
+
+Maintained target/depth, clear, viewport, view, projection, resolve, copy,
+mipmap and presentation steps normalize Carbon arguments into this intent
+surface. They do not import WebGL/WebGPU APIs or decide pass boundaries.
+
+## Post-process graph contract
+
+`Tr2PostProcess2` and `Tr2PostProcessAttributes` are device-free graph classes.
+Trinity owns effect activation and quality gates, LUT ordering, priority/intensity
+volume blending, and the rebuilding of authored effect records. The 56 Carbon
+post-process attributes are exposed as their exact enabled/value pairs; macro
+placeholders are not part of the JavaScript contract.
+
+Live post-processing remains backend work. WebGL and WebGPU executors must
+independently realize temporary and persistent textures, exposure buffers,
+TAA/upscaler history, compute or fragment alternatives, fullscreen passes,
+readback, and loss recovery. They must preserve Carbon's observable pass order,
+but Trinity does not prescribe a shared RHI or serialize those internal passes
+as `TriRenderStep` objects.
+
+## Provenance
+
+CarbonEngine and Fenris Creations (CCP Games) are named for interoperability and
+provenance context. This package's runtime code is CarbonEngineJS original work
+that ports or adapts CarbonEngine class structure and behavior, verified against
+the CarbonEngine C++ source. Not affiliated with or endorsed by CCP Games.

package/dist/_virtual/_rollupPluginBabelHelpers.js

@@ -0,0 +1,153 @@
+function _applyDecs2311(e, t, n, r, o, i) {
+  var a,
+    c,
+    u,
+    s,
+    f,
+    l,
+    p,
+    d = Symbol.metadata || Symbol.for("Symbol.metadata"),
+    m = Object.defineProperty,
+    h = Object.create,
+    y = [h(null), h(null)],
+    v = t.length;
+  function g(t, n, r) {
+    return function (o, i) {
+      n && (i = o, o = e);
+      for (var a = 0; a < t.length; a++) i = t[a].apply(o, r ? [i] : []);
+      return r ? i : o;
+    };
+  }
+  function b(e, t, n, r) {
+    if ("function" != typeof e && (r || void 0 !== e)) throw new TypeError(t + " must " + (n || "be") + " a function" + (r ? "" : " or undefined"));
+    return e;
+  }
+  function applyDec(e, t, n, r, o, i, u, s, f, l, p) {
+    function d(e) {
+      if (!p(e)) throw new TypeError("Attempted to access private element on non-instance");
+    }
+    var h = [].concat(t[0]),
+      v = t[3],
+      w = !u,
+      D = 1 === o,
+      S = 3 === o,
+      j = 4 === o,
+      E = 2 === o;
+    function I(t, n, r) {
+      return function (o, i) {
+        return n && (i = o, o = e), r && r(o), P[t].call(o, i);
+      };
+    }
+    if (!w) {
+      var P = {},
+        k = [],
+        F = S ? "get" : j || D ? "set" : "value";
+      if (f ? (l || D ? P = {
+        get: _setFunctionName(function () {
+          return v(this);
+        }, r, "get"),
+        set: function (e) {
+          t[4](this, e);
+        }
+      } : P[F] = v, l || _setFunctionName(P[F], r, E ? "" : F)) : l || (P = Object.getOwnPropertyDescriptor(e, r)), !l && !f) {
+        if ((c = y[+s][r]) && 7 !== (c ^ o)) throw Error("Decorating two elements with the same name (" + P[F].name + ") is not supported yet");
+        y[+s][r] = o < 3 ? 1 : o;
+      }
+    }
+    for (var N = e, O = h.length - 1; O >= 0; O -= n ? 2 : 1) {
+      var T = b(h[O], "A decorator", "be", true),
+        z = n ? h[O - 1] : void 0,
+        A = {},
+        H = {
+          kind: ["field", "accessor", "method", "getter", "setter", "class"][o],
+          name: r,
+          metadata: a,
+          addInitializer: function (e, t) {
+            if (e.v) throw new TypeError("attempted to call addInitializer after decoration was finished");
+            b(t, "An initializer", "be", true), i.push(t);
+          }.bind(null, A)
+        };
+      if (w) c = T.call(z, N, H), A.v = 1, b(c, "class decorators", "return") && (N = c);else if (H.static = s, H.private = f, c = H.access = {
+        has: f ? p.bind() : function (e) {
+          return r in e;
+        }
+      }, j || (c.get = f ? E ? function (e) {
+        return d(e), P.value;
+      } : I("get", 0, d) : function (e) {
+        return e[r];
+      }), E || S || (c.set = f ? I("set", 0, d) : function (e, t) {
+        e[r] = t;
+      }), N = T.call(z, D ? {
+        get: P.get,
+        set: P.set
+      } : P[F], H), A.v = 1, D) {
+        if ("object" == typeof N && N) (c = b(N.get, "accessor.get")) && (P.get = c), (c = b(N.set, "accessor.set")) && (P.set = c), (c = b(N.init, "accessor.init")) && k.unshift(c);else if (void 0 !== N) throw new TypeError("accessor decorators must return an object with get, set, or init properties or undefined");
+      } else b(N, (l ? "field" : "method") + " decorators", "return") && (l ? k.unshift(N) : P[F] = N);
+    }
+    return o < 2 && u.push(g(k, s, 1), g(i, s, 0)), l || w || (f ? D ? u.splice(-1, 0, I("get", s), I("set", s)) : u.push(E ? P[F] : b.call.bind(P[F])) : m(e, r, P)), N;
+  }
+  function w(e) {
+    return m(e, d, {
+      configurable: true,
+      enumerable: true,
+      value: a
+    });
+  }
+  return void 0 !== i && (a = i[d]), a = h(null == a ? null : a), f = [], l = function (e) {
+    e && f.push(g(e));
+  }, p = function (t, r) {
+    for (var i = 0; i < n.length; i++) {
+      var a = n[i],
+        c = a[1],
+        l = 7 & c;
+      if ((8 & c) == t && !l == r) {
+        var p = a[2],
+          d = !!a[3],
+          m = 16 & c;
+        applyDec(t ? e : e.prototype, a, m, d ? "#" + p : _toPropertyKey(p), l, l < 2 ? [] : t ? s = s || [] : u = u || [], f, !!t, d, r, t && d ? function (t) {
+          return _checkInRHS(t) === e;
+        } : o);
+      }
+    }
+  }, p(8, 0), p(0, 0), p(8, 1), p(0, 1), l(u), l(s), c = f, v || w(e), {
+    e: c,
+    get c() {
+      var n = [];
+      return v && [w(e = applyDec(e, [t], r, e.name, 5, n)), g(n, 1)];
+    }
+  };
+}
+function _checkInRHS(e) {
+  if (Object(e) !== e) throw TypeError("right-hand side of 'in' should be an object, got " + (null !== e ? typeof e : "null"));
+  return e;
+}
+function _identity(t) {
+  return t;
+}
+function _setFunctionName(e, t, n) {
+  "symbol" == typeof t && (t = (t = t.description) ? "[" + t + "]" : "");
+  try {
+    Object.defineProperty(e, "name", {
+      configurable: !0,
+      value: n ? n + " " + t : t
+    });
+  } catch (e) {}
+  return e;
+}
+function _toPrimitive(t, r) {
+  if ("object" != typeof t || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r);
+    if ("object" != typeof i) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return ("string" === r ? String : Number)(t);
+}
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
+  return "symbol" == typeof i ? i : i + "";
+}
+
+export { _applyDecs2311 as applyDecs2311, _checkInRHS as checkInRHS, _identity as identity, _setFunctionName as setFunctionName, _toPrimitive as toPrimitive, _toPropertyKey as toPropertyKey };
+//# sourceMappingURL=_rollupPluginBabelHelpers.js.map

package/dist/_virtual/_rollupPluginBabelHelpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"_rollupPluginBabelHelpers.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}