@carbonenginejs/runtime-resource 0.11.1 → 0.12.1

package/docs/formats/dxbc/reference/classes/README.md

@@ -0,0 +1,9 @@
+# DXBC class catalog
+
+Status: Deprecated
+Scope: `@carbonenginejs/runtime-resource/formats/dxbc` maintained classes
+Audience: Users, maintainers, and automated readers
+Summary: Points to the canonical package-wide class catalog after format-package consolidation.
+
+The maintained DXBC entries now live in the
+[package-wide formats class catalog](../../../../reference/classes/formats.md#dxbc).

package/docs/formats/dxbc/reference/decoded-output.md

@@ -0,0 +1,122 @@
+# Decoded output contract
+
+Status: Evolving
+Scope: `@carbonenginejs/runtime-resource/formats/dxbc` JSON output
+Audience: Shader-tool authors and lowering-backend authors
+Summary: Defines the stable top-level JSON fields and the decoder records consumed by shader-lowering packages.
+
+## Top-level result
+
+`CjsDxbcFormat.read(bytes)` returns:
+
+| Field | Meaning |
+| --- | --- |
+| `source` | Caller-provided diagnostic label. |
+| `container` | Container version, declared size, and chunk summaries. |
+| `program` | Shader stage, shader model, chunk tag, and token count, or `null`. |
+| `inputSignature` | Input signature elements, or `null`. |
+| `outputSignature` | Output signature elements, or `null`. |
+| `patchSignature` | Patch-constant signature elements, or `null`. |
+| `instructions` | Decoded instruction records, or `null` when disabled or absent. |
+
+`Inspect` returns a smaller record containing the container/chunk summary,
+stage name, shader model, and input/output element counts.
+
+## Container records
+
+The container summary includes `version`, `totalSize`, and ordered `chunks`.
+Each chunk record includes its four-character code, byte offset, and payload
+size. JSON output omits raw chunk bytes.
+
+## Program records
+
+Program metadata includes:
+
+- `fourCC`: `SHEX` or `SHDR`;
+- numeric and named program type;
+- major and minor shader-model version; and
+- declared program length in 32-bit words.
+
+Recognized program names are pixel, vertex, geometry, hull, domain, and
+compute. An unknown numeric type remains observable as `"unknown"`.
+
+## Signature elements
+
+Each signature element records its semantic name/index, system-value and
+component types, register index, masks, stream, and minimum-precision value
+when that signature layout provides one.
+
+The reader supports the SM4 and SM5 signature chunk layouts used by `ISGN`,
+`ISG1`, `OSGN`, `OSG1`, `OSG5`, `PCSG`, and `PSG1`.
+
+## Instruction records
+
+Each instruction begins with its source token offset, opcode number/name,
+declared length, and decoded control bits. Depending on the opcode, the record
+may also include:
+
+- destination and source operands with component selection and index records;
+- opcode and operand extensions;
+- declaration-specific fields;
+- resource dimensions and return types;
+- sampler, interpolation, precision, topology, or system-value metadata;
+- custom-data payloads; and
+- unprojected declaration words in `tailTokens`.
+
+Executable instructions reject leftover or missing operand words. Declaration
+records may preserve unfamiliar trailing payload words when their instruction
+framing is valid.
+
+### Compute shared memory and synchronization
+
+Compute thread-group shared-memory declarations expose their register and
+complete allocation shape:
+
+| Declaration | Fields |
+| --- | --- |
+| `dcl_thread_group_shared_memory_raw` | `registerIndex`, `byteCount` |
+| `dcl_thread_group_shared_memory_structured` | `registerIndex`, `structureStride`, `structureCount` |
+
+The declaration operand must identify one immediate thread-group shared-memory
+register. Byte counts and structure strides are positive and DWORD-aligned;
+structured element counts are positive. Any additional well-framed declaration
+words remain observable through `tailTokens`.
+
+The `sync` instruction exposes its numeric `syncFlags` mask and a canonical
+bit-order `syncFlagNames` array. The recognized names are
+`threads_in_group`, `thread_group_shared_memory`,
+`thread_group_uav_memory`, and `global_uav_memory`. These control bits are
+separate from arithmetic result controls, so `sync` never reports saturation.
+Unknown bits remain set in the numeric eight-bit mask even though they have no
+entry in the recognized-name array. Reserved operand and opcode-control bits
+are rejected rather than projected onto the canonical records.
+
+## Shader Model 5.1 bindings
+
+SM5.1 resource declarations may include `bindingRange`:
+
+| Field | Meaning |
+| --- | --- |
+| `rangeId` | Class-local binding-range identity. |
+| `lowerBound` / `upperBound` | Declared register bounds. |
+| `unbounded` | Whether the upper bound represents an unbounded range. |
+| `registerCount` | Finite range size, otherwise `null`. |
+| `registerSpace` | D3D register space. |
+
+Executable resource, sampler, UAV, and constant-buffer operands may include a
+`resourceReference` retaining the range identity, index records, and
+non-uniform flag. Range identity remains separate from the actual register
+index needed by an explicit-binding backend.
+
+SM5.0 declarations keep their direct-register shape.
+
+## JSON conversion
+
+Typed arrays become number arrays, arrays are converted recursively, maps
+become plain objects, sets become arrays, and objects with `toJSON` use that
+projection.
+
+## Related documentation
+
+- [Public API reference](api.md)
+- [Architecture and boundaries](../architecture.md)

package/docs/formats/gr2.md

@@ -32,10 +32,9 @@ const summary = CjsGr2Format.inspect(bytes);
 const asynchronousGraph = await CjsGr2Format.readAsync(bytes);
 ```
 
-The wrapper exposes the normal runtime-resource format metadata and
-`isSupported(bytes)` magic probe. It also exports the migrated
-`CjsFormatGr2` reader engine for compatibility, but new consumers should use
-`CjsGr2Format`.
+`CjsGr2Format` is the one public class: the reader engine plus the normal
+runtime-resource format metadata and the `isSupported(bytes)` magic probe.
+The barrel exports nothing else.
 
 Register it with `CjsResMan` when GR2/GSF should participate in ordinary
 resource loading:

package/docs/formats/hlsl/README.md

@@ -0,0 +1,54 @@
+# Package documentation
+
+Status: Evolving
+Scope: `@carbonenginejs/runtime-resource/formats/hlsl`
+Audience: Users and integrators
+Summary: Documentation home for the compiled Carbon/Trinity effect-container reader.
+
+## Purpose
+
+`@carbonenginejs/runtime-resource/formats/hlsl` reads versions 8 through 15 of the compiled
+effect container used by Carbon/Trinity. It resolves a permutation and exposes
+techniques, passes, stage metadata, render states, signatures, and opaque
+shader bytecode as JavaScript data.
+
+```js
+import CjsHlslFormat from "@carbonenginejs/runtime-resource/formats/hlsl";
+
+const metadata = CjsHlslFormat.read(bytes, {
+    emit: "metadata"
+});
+```
+
+## Where it fits
+
+- Use this package for the effect container and its metadata.
+- Use `@carbonenginejs/runtime-resource/formats/dxbc` to decode supported embedded Direct3D
+  shader bytecode.
+- Translation backends such as `@carbonenginejs/runtime-resource/formats/webgpu` can consume
+  the metadata and bytecode through their own integration layers.
+- `@carbonenginejs/runtime-resource` consumes packaged portable reflection and
+  owns canonical `Tr2EffectRes`/`Tr2Shader` hydration, selection, and caching.
+- `@carbonenginejs/runtime-trinity` consumes that shader graph through its
+  mutable effect/material facade, parameters, options, and sampler overrides.
+
+The package does not compile HLSL source, translate shader instructions,
+construct canonical runtime model instances, or provide a rendering runtime.
+
+## Start here
+
+- [Architecture](architecture.md)
+- [Reading effects](guides/reading-effects.md)
+- [Hydrating JSON output](guides/hydrating-json-output.md)
+- [API reference](reference/api.md)
+- [Advanced analysis exports](reference/advanced-analysis.md)
+- [JSON graph reference](reference/json-graph.md)
+- [Portable body reflection](reference/portable-reflection.md)
+- [Class catalog](reference/classes/README.md)
+
+## Compatibility
+
+Supported input types are `.sm_hi`, `.sm_lo`, and `.sm_depth` compiled effect
+bodies. Unsupported headers, invalid offsets, truncated data, and invalid
+permutation selections fail with an error rather than returning a partial
+success value.

package/docs/formats/hlsl/architecture.md

@@ -0,0 +1,67 @@
+# Architecture
+
+Status: Evolving
+Scope: `@carbonenginejs/runtime-resource/formats/hlsl` implementation boundaries
+Audience: Integrators and maintainers
+Summary: Explains the package boundary, parsing flow, output modes, and platform adapters.
+
+## Ownership boundary
+
+The package owns the compiled Carbon/Trinity effect-container boundary:
+headers, string tables, permutation selection, effect descriptions,
+techniques, passes, render states, stage metadata, signatures, and the
+packaging of opaque shader bytecode.
+
+It does not decode shader instructions, compile source code, or own runtime
+resource binding. Those responsibilities remain with bytecode-format,
+translation, and runtime packages.
+
+## Read flow
+
+```text
+caller bytes
+    -> input and option normalization
+    -> effect header, strings, and permutation axes
+    -> selected compiled body
+    -> techniques, passes, and stage metadata
+    -> json | metadata | raw output
+```
+
+`src/CjsHlslFormat.js` is the supported reader boundary. Binary utilities and
+format-shaped compatibility models live below `src/core` and `src/carbon`.
+Their same-named `Tr2*` classes are internal parser DTOs, not canonical runtime
+model identity, and are not independent package entry points.
+
+## Output modes
+
+- `json` is the default interoperable data graph and may include opaque
+  bytecode and constant-value bytes.
+- `metadata` is a compact, bytecode-free graph for inspection and pipeline
+  planning.
+- `raw` exposes internal effect-model instances for advanced tooling and is
+  not a stable schema.
+- `@carbonenginejs/runtime-resource/formats/hlsl/portable` copies one exact body into a versioned,
+  runtime-neutral source-reflection contract. Authored defaults and programs stay
+  separate from mutable renderer realization.
+
+`runtime-resource` owns canonical `Tr2EffectRes`/`Tr2Shader` hydration,
+permutation selection, and caching. `runtime-trinity` owns the mutable
+effect/material facade, parameters, authored options, and sampler overrides.
+Engines own GPU realization.
+
+The graph shapes are documented in
+[reference/json-graph.md](reference/json-graph.md).
+
+## Platform boundary
+
+`read`, `inspect`, and `toJSON` operate on caller-provided bytes and work
+without filesystem access. `readFile` and the CLI are Node-specific adapters.
+The package has no runtime dependencies.
+
+## Error boundary
+
+Structural failures include the source label and read context where available.
+The reader rejects unsupported versions and unsafe reads instead of silently
+guessing a layout. A selected compiled body can record its own decode failure
+in raw or JSON-oriented inspection data where the format model supports that
+state.

package/docs/formats/hlsl/guides/hydrating-json-output.md

@@ -0,0 +1,62 @@
+# Hydrating JSON output
+
+Status: Evolving
+Scope: `@carbonenginejs/runtime-resource/formats/hlsl` JSON node hydration
+Audience: Advanced users and integrators
+Summary: Explains how callers can replace selected plain JSON nodes with their own constructors.
+
+## Register constructors
+
+The default `json` output uses plain objects. The `classes` option can
+instantiate selected node kinds with caller-provided constructors:
+
+```js
+import CjsHlslFormat from "@carbonenginejs/runtime-resource/formats/hlsl";
+
+const effect = CjsHlslFormat.read(bytes, {
+    classes: {
+        Technique: MyTechnique,
+        StageInput: MyStageInput
+    }
+});
+```
+
+Supported keys are exposed as `CjsHlslFormat.CLASS_KEYS`:
+
+```text
+Root
+Permutation
+EffectDescription
+Technique
+Pass
+StageInput
+Constant
+Resource
+Sampler
+ShaderBytecode
+```
+
+## Reuse a profile
+
+```js
+const reader = new CjsHlslFormat();
+
+reader.SetClass("Technique", MyTechnique);
+reader.SetClasses({ StageInput: MyStageInput });
+
+reader.HasClass("Technique");
+reader.GetClass("Technique");
+
+const effect = reader.Read(bytes);
+```
+
+Hydration changes object prototypes, not the documented field shape. Nested
+records without a class key remain plain JSON-compatible data. Depending on
+the caller's constructors as a serialization schema is discouraged; persist
+the documented graph fields instead.
+
+This feature is caller-selected JSON projection only. It does not consume the
+versioned portable-reflection contract and does not construct canonical
+runtime `Tr2EffectRes` or `Tr2Shader` instances. Canonical
+`CJS_EFFECT_BODY_REFLECTION` hydration belongs to
+`@carbonenginejs/runtime-resource`.

package/docs/formats/hlsl/guides/reading-effects.md

@@ -0,0 +1,64 @@
+# Reading effects
+
+Status: Evolving
+Scope: `@carbonenginejs/runtime-resource/formats/hlsl` read workflows
+Audience: Users and integrators
+Summary: Shows browser-neutral byte reads, permutation selection, inspection, and Node file workflows.
+
+## Read caller-provided bytes
+
+```js
+import CjsHlslFormat from "@carbonenginejs/runtime-resource/formats/hlsl";
+
+const response = await fetch("/shaders/effect.sm_hi");
+const bytes = new Uint8Array(await response.arrayBuffer());
+const effect = CjsHlslFormat.read(bytes);
+```
+
+Use `inspect` when only header and technique summary information is needed:
+
+```js
+const summary = CjsHlslFormat.inspect(bytes, {
+    source: "effect.sm_hi"
+});
+```
+
+## Select a permutation
+
+Without a `permutation` option, the reader applies the container's default
+selection rules. Override individual axes by name and value:
+
+```js
+const effect = CjsHlslFormat.read(bytes, {
+    permutation: [
+        { name: "BLEND_MODE", value: "TRANSPARENT" }
+    ]
+});
+```
+
+A `Map` of names to values is also accepted. Unknown axes or invalid values
+are rejected rather than silently ignored.
+
+## Read compact metadata
+
+```js
+const metadata = CjsHlslFormat.read(bytes, {
+    emit: CjsHlslFormat.OUTPUT_METADATA
+});
+```
+
+Metadata output omits embedded bytecode and constant-value bytes. It retains
+the selected options, techniques, passes, stage resources, signatures, and
+render-state records needed for inspection and pipeline planning.
+
+## Read a file in Node
+
+```js
+const effect = await CjsHlslFormat.readFile("effect.sm_hi");
+```
+
+The CLI provides the same metadata workflow:
+
+```sh
+format-hlsl metadata effect.sm_hi effect.json
+```

package/docs/formats/hlsl/reference/advanced-analysis.md

@@ -0,0 +1,66 @@
+# Advanced analysis exports
+
+Status: Experimental
+Scope: `@carbonenginejs/runtime-resource/formats/hlsl` advanced named exports
+Audience: Translation-tool authors and maintainers
+Summary: Documents unstable helpers for raw graph analysis and binding-manifest construction.
+
+## Stability
+
+These exports support translation and inspection tooling that needs internal
+effect-model objects. Their shapes may change without a major version bump.
+Use `CjsHlslFormat.read(..., { emit: "json" })` or `"metadata"` for the
+supported data contracts.
+
+## `readEffectAnalysis`
+
+```js
+import { readEffectAnalysis } from "@carbonenginejs/runtime-resource/formats/hlsl";
+
+const analysis = readEffectAnalysis(bytes, {
+    source: "effect.sm_hi",
+    permutation: [
+        { name: "BLEND_MODE", value: "TRANSPARENT" }
+    ]
+});
+```
+
+The result contains the loaded effect resource, resolved shader, selected
+option and body-index data, effect description, and a binding manifest when
+an effect description is available.
+
+The returned internal parser-DTO effect resource also has
+`GetShaderByIndex(index)`. It decodes one exact permutation-table slot without
+applying global or local option overrides; it is distinct from the canonical
+runtime-resource method that hydrates and caches `Tr2Shader`. Use the versioned
+portable subpath when the result must cross a package or serialization
+boundary. Its `enumerateUniqueEffectBodies(effectRes)` helper inventories
+first-seen raw body identities without populating the parser's mutable shader
+cache.
+
+## `Tr2EffectBindingManifest`
+
+`Tr2EffectBindingManifest` is an exported advanced class that derives
+register-named constant, resource, sampler, and UAV bindings from an internal
+effect description.
+
+```js
+import {
+    readEffectAnalysis,
+    Tr2EffectBindingManifest
+} from "@carbonenginejs/runtime-resource/formats/hlsl";
+
+const analysis = readEffectAnalysis(bytes);
+analysis.bindingManifest instanceof Tr2EffectBindingManifest;
+```
+
+## Render-context helpers
+
+`Tr2RenderContextEnum` contains the format's stage and render-context numeric
+constants. `tr2ShaderStageName(value)` maps a known stage value to its
+readable name. Both are advanced compatibility helpers rather than a stable
+cross-package enumeration contract.
+
+## Related documentation
+
+- [Portable body reflection](portable-reflection.md)

package/docs/formats/hlsl/reference/api.md

@@ -0,0 +1,98 @@
+# API reference
+
+Status: Evolving
+Scope: `@carbonenginejs/runtime-resource/formats/hlsl` supported reader API
+Audience: Users and integrators
+Summary: Documents the reader class, options, output modes, and Node adapters.
+
+## Imports
+
+The package root exports `CjsHlslFormat` as both the default and a named
+export:
+
+```js
+import CjsHlslFormat from "@carbonenginejs/runtime-resource/formats/hlsl";
+import { CjsHlslFormat as NamedReader } from "@carbonenginejs/runtime-resource/formats/hlsl";
+```
+
+Additional named exports intended for advanced tooling are documented
+separately in [advanced-analysis.md](advanced-analysis.md).
+
+The versioned `@carbonenginejs/runtime-resource/formats/hlsl/portable` subpath exposes exact
+version-15 body-index reflection plus first-seen exact-byte unique-body
+enumeration for backend packagers. See
+[portable-reflection.md](portable-reflection.md).
+
+## Constructor
+
+```js
+const reader = new CjsHlslFormat({
+    emit: "json",
+    source: "effect.sm_hi",
+    permutation: null,
+    classes: {}
+});
+```
+
+Options are reusable on an instance and can be overridden per call:
+
+- `emit`: `"json"` (default), `"metadata"`, or advanced `"raw"` output.
+- `source`: a caller-supplied label used in diagnostics and output.
+- `permutation`: a `Map` or an array of `{ name, value }` selections.
+- `classes`: constructors used for caller-selected JSON-node projection; this
+  is not canonical runtime shader hydration.
+
+## Instance methods
+
+- `SetValues(options)` updates the reusable profile and returns the reader.
+- `GetValues(options)` returns effective values with optional overrides.
+- `SetClasses(classes)` and `SetClass(type, Class)` configure hydration.
+- `GetClass(type)` and `HasClass(type)` inspect hydration registrations.
+- `Read(input, options)` parses input and emits the configured graph.
+- `Inspect(input, options)` returns header and technique summary data.
+- `ToJSON(value)` converts reader output to JSON-compatible data.
+
+## Static methods
+
+- `CjsHlslFormat.isSupported(input)` performs a header-level support check.
+- `CjsHlslFormat.read(input, options)` performs a one-shot read.
+- `CjsHlslFormat.inspect(input, options)` performs a one-shot inspection.
+- `CjsHlslFormat.toJSON(value)` converts output to JSON-compatible data.
+- `CjsHlslFormat.readFile(path, options)` reads and parses a file in Node.
+
+Inputs may be `Uint8Array`, `ArrayBuffer`, `Buffer`, or `DataView` values.
+Supported container versions are 8 through 15.
+
+## Constants
+
+The class exposes `OUTPUT_JSON`, `OUTPUT_METADATA`, `OUTPUT_RAW`,
+`CLASS_KEYS`, `type`, `mediaTypes`, `inputTypes`, `outputTypes`, and
+`debugOutputTypes`. `inputTypes` contains `sm_hi`, `sm_lo`, and `sm_depth`.
+
+## Output stability
+
+The `json` and `metadata` modes are the supported data contracts described in
+[json-graph.md](json-graph.md). `raw` returns internal parser-DTO
+`Tr2EffectRes` objects, not the canonical runtime-resource class, and may
+change without a major version bump.
+
+## Repository metadata adapter
+
+The repository provides a development script that writes metadata JSON. It is
+not installed as a package `bin`:
+
+```sh
+npm run metadata:hlsl -- effect.sm_hi
+npm run metadata:hlsl -- effect.sm_hi effect.json
+```
+
+When the output path is omitted, the CLI writes `<input-name>.json` in the
+current working directory.
+
+## Related documentation
+
+- [Reading effects](../guides/reading-effects.md)
+- [Hydrating JSON output](../guides/hydrating-json-output.md)
+- [Advanced analysis exports](advanced-analysis.md)
+- [Portable body reflection](portable-reflection.md)
+- [Class catalog](classes/README.md)

package/docs/formats/hlsl/reference/classes/README.md

@@ -0,0 +1,11 @@
+# Class catalog
+
+Status: Deprecated
+Scope: `@carbonenginejs/runtime-resource/formats/hlsl` maintained classes
+Audience: Users, maintainers, and automated readers
+Summary: Points to the canonical package-wide catalogs after format-package consolidation.
+
+The maintained HLSL format entries now live in the
+[package-wide formats class catalog](../../../../reference/classes/formats.md#hlsl).
+Canonical runtime effect-resource and shader-reflection entries live in the
+[resources class catalog](../../../../reference/classes/resources.md).

package/docs/formats/hlsl/reference/json-graph.md

@@ -0,0 +1,100 @@
+# JSON and metadata graphs
+
+Status: Evolving
+Scope: `@carbonenginejs/runtime-resource/formats/hlsl` emitted data
+Audience: Users and integrators
+Summary: Documents the default JSON graph, compact metadata graph, and permutation selection.
+
+## Default JSON graph
+
+`emit: "json"` is the default:
+
+```text
+Root
+|- version, compilerVersion, sourcePath, bodyCount, loadError
+|- permutations: Permutation[]
+`- effect: EffectDescription | null
+   |- version, effectName, annotations, readError
+   `- techniques: Technique[]
+      `- passes: Pass[]
+         |- renderStates: { key, value }[]
+         `- stageInputs: (StageInput | null)[]
+            |- constants: Constant[]
+            |- resources: Resource[]
+            |- uavs: Resource[]
+            |- samplers: Sampler[]
+            |- signature
+            `- bytecode: ShaderBytecode | null
+```
+
+Bytecode values are opaque payloads. A compatible bytecode-format package
+must decode their instruction streams.
+
+## Permutation selection
+
+By default, `effect` represents the container's default option set. Select
+another compiled body with an array or `Map`:
+
+```js
+const effect = CjsHlslFormat.read(bytes, {
+    permutation: [
+        { name: "BLEND_MODE", value: "TRANSPARENT" }
+    ]
+});
+```
+
+## Metadata graph
+
+`emit: "metadata"` returns compact inspection data without bytecode,
+constant-value bytes, or runtime handles:
+
+```text
+MetadataRoot
+|- version, compilerVersion, sourcePath, bodyCount, loadError
+|- permutations: Permutation[]
+|- bodyIndex
+|- selectedOptions: Option[]
+`- effect: MetadataEffect | null
+   `- techniques: Technique[]
+      `- passes: Pass[]
+         |- renderStates: RenderState[]
+         `- stageInputs: (StageInput | null)[]
+            |- constantValueSize
+            |- constants: Constant[]
+            |- resources: Resource[]
+            |- uavs: Resource[]
+            |- samplers: Sampler[]
+            |- annotations
+            `- signature
+```
+
+Each render-state record retains its numeric `key` and `value`. Known state
+types can also include readable or typed fields such as `name`, `valueName`,
+`valueFloat`, `valueHex`, or `valueFlags`.
+
+## Raw graph
+
+`emit: "raw"` returns the internal parser-DTO `Tr2EffectRes` graph. It is not
+the canonical runtime-resource class. It allows advanced callers to resolve
+multiple permutations after one parse, but it is not a stable or
+serialization-safe schema.
+
+Raw stage and library inputs retain authored `sourceConstantValueSize` /
+`sourceConstantValues` separately from Carbon-compatible mutable constant
+buffers. Libraries retain their source `cjsShaderBytecode` directly. Use
+`@carbonenginejs/runtime-resource/formats/hlsl/portable` to copy those facts into a validated
+handle-free contract.
+
+## Compatibility and failures
+
+The reader supports compiled effect versions 8 through 15. The root or
+selected effect can contain format-defined error fields when a compiled body
+cannot be decoded. Invalid input reads and unsupported layout decisions throw
+rather than being filled with guessed values.
+
+## Related documentation
+
+- [API reference](api.md)
+- [Advanced analysis exports](advanced-analysis.md)
+- [Portable body reflection](portable-reflection.md)
+- [Reading effects](../guides/reading-effects.md)