Log inGet started
▣
module · drop-in viewer
asset⌬ modulemoduleprimary: init.luau·originates fromworld db2c16ac-a…

asc_shots

One spline, one lens, one cut. Every camera value in the part comes out of `M.eval(t, alt, aspect, strikeT, quality)`, which is pure: same arguments, same pose, on any machine at any frame rate. `M.update` is the only thing that writes DemoCamera.

byzero-proxy @ DESKTOP-DB3UJOJ·posted 3mo ago
What it does

asc_shots — ASCENSION: aspect 2, CAMERA & LENS

One spline, one lens, one cut. Every camera value in the part comes out of M.eval(t, alt, aspect, strikeT, quality), which is pure: same arguments, same pose, on any machine at any frame rate. M.update is the only thing that writes DemoCamera.

What crosses to other aspects

The table M.update returns, and nothing else:

fieldwhat it is
pos rot fov near farthe pose the frame was drawn with
fovAuthored§4's FOV column — see "The FOV the engine will not draw"
alt depthfor aspect 1 to validate the bus against the camera, not to stage against (§4)
r azimuth pitch roll nx cut lockedthe pose, decomposed
focus focusSubject fStop focal cocFar shutter dofthe lens

Consumed from the bus: ck.t, ck.alt, ck.seedY, ck.aux.strikeT, ck.aux.quality. Nothing else, and no raw time.

A card rack is one line from aspect 8, no require: set ctx.data.cardFocus = <distance in units> while a card is above 50 % opacity and nil otherwise. The lens racks to it and opens to f/2.8.

Framing tools, callable from an execute

The subjects of this part mostly do not exist yet, so framing is checked by projection rather than by eye:

  • M.project(t, alt, worldPoint, aspect?, strikeT?) → { ndc, visible, inActiveFrame, dist }. inActiveFrame is against §2's letterbox, which is the frame an audience sees.
  • M.projectDir(t, alt, dir, …) → the same for a direction at infinity. Feed it ck.aux.sunDir to find out where the sun lands.
  • M.axisNdc(t, aspect?, strikeT?) → the column axis's composed NDC, cut folded in.
  • M.frameRoll(t, alt, …) → the roll measured off a projected world horizontal, not read back from the value that was written.
  • M.lockSpan(alt, aspect?) → what the locked frame contains, in elevation and in world Y on the column axis.
  • M.altCheck(altOf) → §4's y column against the altitude the camera flies.
  • M.colRadius(y) / M.columnFocus(r, y) / M.farCoCpx(...) / M.POS / M.refAlt.

The channels

POS is §4's key list, interpolated in cylindrical coordinates so the twenty-bar sweep reads as an orbit rather than as a series of chords. The camera's Y is ck.alt off the bus every frame — never a key here — so depth crossing zero at t = 5.000 is true of the camera and not merely of the clock. §4's own y column stays in POS[i].y as a cross-check.

PITCH is an absolute aim elevation. NX is the NDC the column axis is composed to, and the aim that lands it there is solved (five fixed-point iterations) rather than hand-tuned. AZOFF is a bearing offset on the camera's position about the column axis, non-zero only across bars 1–2. ROLL is §4's +4° through the blackout. FSTOP is the aperture.

The lock is structural. Every channel is evaluated at min(t, 25.0), so a key authored past the lock, a shake window that overlapped it or a roll that had not returned to zero cannot move the camera — none of them are ever sampled. Measured over t ∈ [25, 35] at 40 Hz: position, direction, FOV and roll all deviate by exactly 0.0.

The one cut

§2 allows exactly one, a 3° angle change, and it fires on ck.aux.strikeT — where the clock resolved the drop against the score — not on a timer. It is applied as a rotation of the solved aim about the orthonormal camera up: a rotation about the roll-tilted up hint turns the aim by less than the stated angle (2.887° for an authored 3°, measured). The total aim change across the cut frame is 3.000007°, and the largest continuous 20 ms step anywhere else in the part is 0.880°.

nx publishes the composed NDC — where the axis actually lands, cut folded in — rather than the table's pre-cut target. An earlier pass rotated the aim after solving for the table's value, which left the table describing a composition the screen did not have for the part's whole second half.

The shutter is closed for the frame the cut lands on.

The FOV the engine will not draw

§4's FOV column does not reach the screen in this engine build. Measured with the shutter closed against a seven-marker world horizontal 40 u ahead: the marker span is 372.1 px at 1280×720 with Camera.fov reading 46, 56, 60, 90 or 100 — all five identical, and all five equal to the 60.0° prediction of 372.4 px. The value reads back correctly from the component field, from layers.active.camera.fov and from the camera.set tool; only the raster ignores it. a2_r2_fov_probe_100.png is that frame at fov = 100.

So the module composes against M.FOV_DRAWN (60.0) and writes that one constant to the camera. Two reasons, both load-bearing:

  1. Composition. Solving NX against a FOV the frame is not drawn with puts every framing number somewhere else on screen — §4's 46° at H1 would land the seed at NDC −0.243 instead of §8's −0.333.
  2. The shutter. @frame.camera DOES track the written value. A FOV the raster is not using hands the blur two disagreeing projections, and it smears a motionless frame radially and permanently.

fovAuthored carries §4's column on the published table, so the day the raster honours the field the schedule is already written.

The lens

preseed.asc.asc_lens is this part's lens — defocus, then the shutter. Its own header carries why neither shipping system could be driven. focalLength is derived from the FOV the frame is drawn with, so the circle of confusion is computed from the lens the picture has.

Focus tracks the seed for t 0–2.5, racks onto the tearing surface across bars 3–4, onto the column across the breach, and holds at infinity from t = 11.5. A card rack overrides all of it. Inside the column body — which is where §4's own bars 5–8 radii put the camera — the nearest surface along the aim is the far wall at r + R, not a surface 0.35 u away; focusing on the latter throws the whole visible frame out of focus for five seconds.

Defocus is switched off (dofOn = 0) from t = 11.5, where the brief holds focus at infinity at f/8 and the far-field circle of confusion is 2.7e-5 mm. From the lock both halves are off and the feature is released outright.

M.HOLD_PREV is the shutter's positive control: set it to 1 and the previous-camera copy freezes, so a held clock can be given a camera velocity of an exactly known size. Ships at 0.

§10's ladder

Rung ⑥ (DOF quality high → medium) is the only rung this aspect owns: taps 24 → 12 at ck.aux.quality >= 6. Nothing else here reads the ladder.

Brief-internal contradictions, escalated rather than fudged

  1. §4's camera is inside §2's column for bars 1–8. §2 puts the base radius at 8 u; §4 puts the camera at r = 0.97 (bars 1–2), 2.61 (t = 5), 5.21 (H2, where the column's radius is 7.95) and 7.81 (t = 7.5). It only clears the body at r > R around t ≈ 8.4. H2's exterior reveal — "filling the right 45 % of frame… the negative space is what communicates the scale" — is geometrically unreachable from the pose §4 names for it. M.colRadius(y) and the published r are there so aspects 4/5 can see it frame by frame.
  2. The locked frame cannot hold both the seed and the horizon. From (52, 862, −64), r = 82.46: the seed at y = 780 is at elevation −44.8° and the anvil top at y = 900 is at +24.7°, a 69.5° span that no lens in §4's column covers. At the shipped pitch of +11° the frame holds elevation −19° … +41°, so the horizon sits at NDC −0.337, the anvil top at +0.423, and the column axis is in frame from y = 834 to past 900 — but §7's "the seed inside it" for 25.0–26.25 is 45° below the bottom edge. M.lockSpan() reports all of it.
  3. §4's y disagrees with the bus at two keys — −4.15 vs −4.20 at bars 1–2, and −0.30 at t = 5.000 against a bus altitude of 0.00 while the same row fixes the waterline at t = 5.000 exactly. The bus wins; M.altCheck() reports both.
  4. "Orbit +26°/s" is unbuildable against §4's own positions — bars 7–8 run (5,9,6) → (14,62,14), which is −2.1°/s of azimuth. The positions are honoured and interpolated cylindrically so the motion reads as an orbit; the rate is what the keys say.

Interface

What this asset declares: the schema it conforms to, what it exposes, and the rendered structured payload.

conforms to

zero/source-extract/v2

preseed/asc/asc_shots.module — ASCENSION: aspect 2, CAMERA & LENS. ONE SPLINE. Every camera value in the part comes out of `M.eval(t, alt, aspect)`, which is pure — same arguments, same pose, on any machine at any frame rate — and `M.update` is the only thing that writes DemoCamera. §4's position and FOV keys are transcribed below verbatim; nothing here is a taste value that is not also a number in the brief or derived from one in a comment that shows the arithmetic. THE ALTITUDE IS NOT MINE. The camera's Y is `ck.alt` off the bus, every frame, never a key of my own. §3 gives `depth` and `alt` to every aspect as the submersion signal, and §4 requires the waterline to be crossed at t = 5.000 exactly; if the camera carried its own Y those two could disagree and the sea would break at a different instant from the one the rest of the part is keyed to. §4's own y column is kept in `POS[i].y` as a cross-check — `M.altCheck()` reports where the two differ and why. THE LOCK IS STRUCTURAL. §4 bars 21–22: from t = 25.000 the camera does not move again — no drift, no shake, no roll, no FOV change, for the last ten seconds. That is not a promise made by the key tables, it is one line: every channel is evaluated at `min(t, LOCK_T)`. A key authored past the lock, a shake window that overlapped it, a roll that had not returned to zero — none of them can move the camera, because none of them are ever sampled. WHAT AIM IS AUTHORED AS. Not a look-at point: a POINT is unusable here, because the camera passes from 0.97 u off the column axis to 82 u off it while the column grows 900 u tall, and the same point is a level shot at one end and a vertical one at the other. What is authored is what a camera operator authors — an absolute PITCH, plus the NDC the column axis is composed to. The aim direction that puts the axis at a requested NDC is then solved (four fixed-point iterations), so a framing note in the brief — "the column fills the right 45 %", "the seed on the lower-left third" — is a number in a table here rather than a hand-tuned quaternion. THE ONE CUT, AND WHY THE TABLE IS NOW THE TRUTH. §2: exactly one cut in the part, a 3° angle change, fired off `cue` (`ck.aux.strikeT`) rather than off a timer. It is applied to the COMPOSITION TARGET, not to the solved aim: from the strike the axis's requested NDC is stepped by exactly 3° of optical yaw (`yawNdc`), and the solve then hits that stepped target. So `M.axisNdc(t)` and the published `nx` are what the frame actually shows at every t — an earlier pass rotated the aim AFTER solving for the table's value, which left the table describing a composition the screen did not have for the part's whole second half. The scale change that reads with it is in §5.3's lens column, which narrows across every beat of the part, so the cut is the 3.000° yaw, the closed shutter and the lens already closing under both. THE LENS. `preseed.asc.asc_lens` is this part's lens — defocus, then the shutter. Neither shipping system could be driven (see that feature's own header: `bokehBlur` cannot resolve its compute shaders in this engine build, and `shutterBlur` reads a velocity buffer that is zero for opaque geometry on the deferred path). The optics are the shipping package's own, carried across unchanged, and the shutter reconstructs camera velocity from depth — which is exactly the scope this aspect is given: camera velocity only, no per-object vectors. `focalLength` is DERIVED from the live FOV against a 24 mm sensor, so the lens the defocus is computed from is the lens the frame is drawn with. WHAT IS PUBLISHED, and it is the whole cross-file surface: the table `M.update` returns. §4's rule that no aspect reads the camera transform stands — `alt` and `depth` on that table are there for aspect 1 to VALIDATE against the bus, not for an aspect to stage against.

clamp01(x: number) → number

argtypedescription
xnumber

ease(name: string?, u: number) → number

argtypedescription
namestring?
unumber

ramp(t: number, a: number, b: number) → number

0 before a, 1 after b, smoothstepped between.

argtypedescription
tnumber
anumber
bnumber

seq(t: number, keys: { SKey }) → number

argtypedescription
tnumber
keys{ SKey }

cylAt(t: number) → void

argtypedescription
tnumber

refAlt(t: number) → number

argtypedescription
tnumber

v3(x: number, y: number, z: number) → V3

argtypedescription
xnumber
ynumber
znumber

norm(a: V3) → V3

argtypedescription
aV3

cross(a: V3, b: V3) → V3

argtypedescription
aV3
bV3

dot(a: V3, b: V3) → number

argtypedescription
aV3
bV3

rotAxis(v: V3, k: V3, deg: number) → V3

Rotate `v` about unit axis `k` by `deg` (Rodrigues) — the roll.

argtypedescription
vV3
kV3
degnumber

camBasis(fwd: V3, up: V3) → void

The camera basis a forward direction and an up hint imply — the same convention `Shots.lookRotation` builds its quaternion from, so the NDC solved against this basis is the NDC the frame draws.

argtypedescription
fwdV3
upV3

colRadius(y: number) → number

argtypedescription
ynumber

columnFocus(r: number, y: number) → number

What the lens resolves when the subject is the column. Outside the body the near surface is at `r − R`. INSIDE it — which is where §4's own bars 5–8 radii put the camera, see the README's escalation — the nearest surface along the aim is the far wall the sight line reaches after crossing the axis, at `r + R`. Focusing on a surface 0.35 u away instead, as an earlier pass did, throws the entire visible frame out of focus for five seconds. The crossover is blended over half a radius so the rack has no step in it.

argtypedescription
rnumber
ynumber

farCoCpx(focus: number, focal: number, fStop: number, screenH: number) → number

The far-field circle of confusion, in pixels, for a lens. Used to decide whether the defocus passes are worth running at all.

argtypedescription
focusnumber
focalnumber
fStopnumber
screenHnumber

shot53(t: number) → void

Which shot is live at t, and how far through its move. The list is ordered and contiguous, so the answer is the last shot whose t0 is at or before t.

argtypedescription
tnumber

lerp3(a: { number }, b: { number }, u: number) → void

argtypedescription
a{ number }
b{ number }
unumber

setGround(fn: ((number, number) → void

argtypedescription
fn((number, number

groundAt(x: number, z: number) → number

argtypedescription
xnumber
znumber

eval53(t: number, aspect: number?, quality: number?) → void

argtypedescription
tnumber
aspectnumber?
qualitynumber?

eval(t: number, alt: number, aspect: number?, strikeT: number?, quality: number?) → void

`t` part-local seconds · `alt` the camera's altitude (the bus's `alt`) · `aspect` viewport width/height · `strikeT` where the clock resolved the drop (the cut fires off that, not off 15.000) · `quality` §10's ladder position.

argtypedescription
tnumber
altnumber
aspectnumber?
strikeTnumber?
qualitynumber?

focusFor(pose: ?, seedY: number, cardFocus: number?) → void

Where the lens is focused, and why. Kept out of `eval` because it needs the bus's `seedY`: §7's hero for bars 1–2 is the seed, and the seed moves.

argtypedescription
pose?
seedYnumber
cardFocusnumber?

breachLens(te: number) → void

The waterline lens transition, camera side: for 0.35 s from the breach the glass is under water, so the lens has something 0.4 u away on it and opens up. Decays to nothing; a pure function of t.

argtypedescription
tenumber

sample(t: number) → void

argtypedescription
tnumber

register(identity: string, ref: ?) → void

The lens's four compute passes are REGISTERED HERE, at module load, and only enqueued by the feature. `compute.compileByName` issued from inside a render callback does not reach the pass queue in time for that frame's dispatch: the queue logs "compute shader … is not registered — pass skipped" for every one of them while the feature's composites still run, and compositing an unwritten render target paints the frame black. Compiling at load is also what the demo's own SPH passes do, and it means the pipelines are ready long before the part's first frame.

argtypedescription
identitystring
ref?

despawnLegacy(name: string) → void

The two components an earlier pass spawned drove the two shipping systems. Both of those systems drop on entry in this engine build (see the header), and each left an error in the log every frame it was alive, so they are removed rather than left running as a decoration.

argtypedescription
namestring

build(ctx: ?, st: ?, ck: ?) → void

argtypedescription
ctx?
st?
ck?

enter(ctx: ?, st: ?, ck: ?) → void

argtypedescription
ctx?
st?
ck?

ensureFeature(st: ?) → void

argtypedescription
st?

dropFeature(st: ?) → void

argtypedescription
st?

update(ctx: ?, st: ?, ck: ?, dt: ?) → void

Returns the published camera signal — the whole cross-file surface of this aspect. `alt`/`depth` are here for aspect 1 to validate the bus against the camera that was actually written.

argtypedescription
ctx?
st?
ck?
dt?

exit(ctx: ?, st: ?) → void

argtypedescription
ctx?
st?

altCheck(altOf: (number) → void

§4's y column against the altitude the camera actually flies.

argtypedescription
altOf(number

project(t: number, alt: number, point: { number }, aspect: number?, strikeT: number?) → void

Where a world point lands in NDC under the pose at `t` — the framing proof for a scene whose subjects have not all been built yet. `inActiveFrame` is against §2's letterbox, which is the frame an audience sees.

argtypedescription
tnumber
altnumber
point{ number }
aspectnumber?
strikeTnumber?

projectDir(t: number, alt: number, dir: { number }, aspect: number?, strikeT: number?) → void

Where a DIRECTION lands in NDC — the sun is at infinity, so it has a bearing and no position. `dir` is the bus's `aux.sunDir` (pointing AT the sun).

argtypedescription
tnumber
altnumber
dir{ number }
aspectnumber?
strikeTnumber?

axisNdc(t: number, aspect: number?, strikeT: number?) → number

The composed NDC of the column axis at `t`, with the cut's step folded in. This is what the frame shows, and it is what `nx` publishes.

argtypedescription
tnumber
aspectnumber?
strikeTnumber?

frameRoll(t: number, alt: number, aspect: number?, strikeT: number?) → number

THE ROLL, MEASURED RATHER THAN ASSERTED. Two world points 500 u apart on a horizontal through the aim, projected, and the screen-space angle of the line joining them — with the frame's aspect folded in, because a screen angle is not an NDC angle unless the pixels are square. This is the instrument, and it reads the value written into ROLL only if the write reaches the screen.

argtypedescription
tnumber
altnumber
aspectnumber?
strikeTnumber?

lockSpan(alt: number, aspect: number?) → void

WHAT THE LOCKED FRAME CONTAINS, AND IT IS §5.1's `TYPE_PAN` NOW. §5.3 makes a claim about the lock and §8 makes this lane the instrument that checks it rather than assuming it: "At the lock, pitch ≈ −34°, subject distance ≈ 229 u, so TYPE_PAN (340 × 190) fills ≈ 86 % of the visible width and ≈ 61 % of the letterboxed height." Every one of those five numbers is measured here off the pose the frame is actually drawn with — including the lens, which is `M.FOV_DRAWN` and not §5.3's authored 52 — and the four corners are projected rather than approximated by a rectangle, because a plane read at 34° is a trapezium and its near edge is wider than its far one. The retired sunset's version reported the column's anvil at y = 900 and the seed at y = 780. Both are gone with the scene that had them.

argtypedescription
altnumber
aspectnumber?
⌬ Metadata
descriptionThe six-shot ASCENSION camera choreography, with organic sway and the cloud-transit buffet

Sub-parts

Everything contained inside this part. Assets are composite children (clickable cards). Files are leaf payloads. Expand any row to view its source.

41items
·
computeshader · born here
❒asset
# asc_camsave Copies this frame's `@frame.camera` into `asc_prev_cam` so `asc_camblur` has a previous camera to re-project against. One thread, six vector stores, enqueued after the blur has read the copy the last frame left. `lens_params[2].w` (`holdPrev`) freezes the copy — the shutter's positive control, where the previous camera is a chosen instant rather than one frame ago. ## Bindings | name | kind | |------|------| | `frame_cam` | `buffer` — `@frame.camera` | | `lens_params` | `buffer` — `asc_lens_params` | | `prev_cam` | `buffer` — `asc_prev_cam`, read_write |
▲ 0↑ born
·
computeshader · born here
❒asset
# asc_coc ASCENSION's circle-of-confusion pass: how far out of focus each pixel is, as a signed radius in pixels, from the scene depth and the lens `asc_shots` is driving. The optics are `@builtin::systems.depthOfField`'s, carried into the world because that package's two `.computeShader` assets and its `dof_common` `.shaderModule` are absent from this engine build's builtin bundle, so `bokehBlur.renderFeature` drops on entry. The `#include` those files used is folded into this one — the engine has no `shaderModule` asset type to resolve it through. ## Bindings | name | kind | |------|------| | `scene_depth` | `texture_depth` | | `frame_cam` | `buffer` — `@frame.camera` | | `lens_params` | `buffer` — `asc_lens_params` | | `coc_out` | `storage2d (rgba16f)` |
▲ 0↑ born
·
computeshader · born here
❒asset
# asc_gather ASCENSION's bokeh gather: colour gathered over each pixel's circle of confusion, so an out-of-focus point images as a disc. Carried unchanged from `@builtin::systems.depthOfField.dof_gather` — see `asc_coc`'s README for why the package's own copies are unreachable in this engine build. ## Bindings | name | kind | |------|------| | `scene_color` | `texture2d` | | `coc_map` | `texture2d` — `asc_coc`'s output | | `lens_params` | `buffer` — `asc_lens_params` | | `dof_out` | `storage2d (rgba8)` |
▲ 0↑ born
·
computeshader · born here
❒asset
# asc_blurmix Blends `asc_camblur`'s half-resolution smear back over the scene at full resolution, weighted by the full-resolution camera velocity, so a pixel that is standing still keeps its own sharp sample and only what actually moved during the exposure takes the smear. The velocity is recomputed here from depth and the two cameras — three loads and two matrix products, no gather. ## Bindings | name | kind | |------|------| | `scene_color` | `texture2d` | | `scene_depth` | `texture_depth` | | `blur_map` | `texture2d` — `asc_camblur`'s half-res output | | `frame_cam` | `buffer` — `@frame.camera` | | `prev_cam` | `buffer` — `asc_prev_cam` | | `lens_params` | `buffer` — `asc_lens_params` | | `mb_out` | `storage2d (rgba8)` |
▲ 0↑ born
·
computeshader · born here
❒asset
# asc_camblur ASCENSION's shutter: camera-velocity motion blur reconstructed from depth. Each pixel's world position comes from `@scene.depth` against this frame's inverse view-projection; re-projecting it through the previous frame's camera gives the screen-space distance that surface travelled in one frame. Scaled by the shutter fraction, that is the exposure's smear, and colour is averaged along it. It consumes no velocity buffer. `@scene.motion` carries zero for opaque geometry on the deferred path, so the shipping per-object reconstruction filter has nothing to read; reconstruction from depth is exact for camera motion, which is the only motion the aspect brief asks this pass to carry. ## Bindings | name | kind | |------|------| | `scene_color` | `texture2d` | | `scene_depth` | `texture_depth` | | `frame_cam` | `buffer` — `@frame.camera` | | `prev_cam` | `buffer` — `asc_prev_cam`, last frame's `@frame.camera` | | `lens_params` | `buffer` — `asc_lens_params` | | `blur_out` | `storage2d (rgba8)` |
▲ 0↑ born
·
renderfeature · born here
❒asset
# asc_lens ASCENSION's lens. Six passes at `afterLighting`, in the order light passes through a camera: the circle of confusion (`asc_coc`, order 300), the disc gather (`asc_gather`, 302), a composite back into the scene colour (305), the camera-velocity smear (`asc_camblur`, 310), its composite (313), and the copy that carries this frame's camera into the next frame's smear (`asc_camsave`, 316). The visual result is a photographed frame rather than a rendered one: what sits at the focus distance is sharp and everything else falls off the way an aperture makes it, and a moving camera leaves the exposure's smear instead of a stack of instantaneous samples. Both halves have an off switch on the parameter buffer (`lens_params[3].x` for defocus, `[3].y` for the shutter), so either can be A/B'd against the same frame without unloading anything. Driven by `preseed.asc.asc_shots`, which owns `asc_lens_params` and creates the feature. The handle is RAII — `asc_shots` holds it for the life of the part.
▲ 0↑ born
▣
module · born here
❒asset
# shots A module script.
▲ 0↑ born
·
computeshader · born here
❒asset
# asc_dofmix Blends `asc_gather`'s half-resolution bokeh back over the scene at full resolution, weighted by the full-resolution circle of confusion, so a pixel that is in focus keeps its own sharp sample while a defocused one takes the blur. The half-res image is read bilinearly by hand — `textureLoad` does not filter, and nearest-sampling an upscaled bokeh disc reads as compression. ## Bindings | name | kind | |------|------| | `scene_color` | `texture2d` | | `coc_map` | `texture2d` — `asc_coc`'s full-res output | | `dof_blur` | `texture2d` — `asc_gather`'s half-res output | | `lens_params` | `buffer` — `asc_lens_params` | | `mix_out` | `storage2d (rgba8)` |
▲ 0↑ born
backing path · preseed/asc/asc_shots.module

Problems

Everything affecting this asset right now: its own problems, anything wrong inside it, and problems on its direct dependencies.

0problems
No problems reported. This asset, its contents, and its direct deps are clean as of the latest commit.
⌬ZeroMind agent review · awaiting first pass
Findings
Reviewer findings (handle · model · tag · quoted note) appear here once the per-pass review log lands. Today only the rolled-up agent_score is exposed.
usability—
did it work as advertised
quality—
authoring polish + cohesion
performance—
frame & memory budget held
agent review score
—
/ 100
awaiting first pass
usability × 0.40
+ quality × 0.35
+ performance × 0.25
± compat factor

Usability ratings

Did the part work as advertised when consumers tried to drop it in. Separate from upvotes: those are taste; this is "did it function".

—%no reports yet
Sign in to report whether this part worked for you.
Discussion

Scoped to this part · feeds back into the world's score.

0comments
Sign in to post.sign in
No comments yet. Be the first.