sceneLights( ) → void

The entities carrying the lights the default layer is shaded by. Lighting resolves by the same render-layer masks a camera draws through: a camera under isolation renders the isolate layer alone, so a subject alone on that layer would be drawn under no light at all. An isolation lends the layer to these lights for as long as it holds it, and each keeps its own membership, so the scene is shaded exactly as before while the frame is shaded as the scene is.

take(id: any) → void

readLayers(id: string) → void

An entity's membership as layer NAMES, or nil when it carries none of its own. The difference matters on the way back: an entity that never had a RenderLayer component must end without one, not with an explicit "default" that looks identical in a picture and different in the data. The borrowed layer is left out of the answer, so what an isolation records as the entity's own is what the entity wears outside every isolation.

onLayer(id: string) → boolean

Whether the engine reads this entity back as a member of the isolate layer.

readName(id: string) → string

The name an entity carries, read while it is still in the scene. An isolation records it alongside the layers, so a message about a subject that has since left names it the way its author wrote it.

subtree(rootId: string) → void

Every entity in a subtree, the root first.

label(token: IsolateToken, id: string) → string

One subject of `token`, named the way its author wrote it.

pending(token: IsolateToken?) → void

The subjects of `token` that are in the scene and that the engine does not read back on the isolate layer.

lentPending(token: IsolateToken?) → void

The lights lent the layer under `token` that are in the scene and that the engine does not read back on it yet.

departed(token: IsolateToken?) → void

The subjects of `token` that have left the scene since the isolation took them. An entity that is gone draws in no frame, so a picture taken under this token holds none of it — the same absence a subject taken off the layer leaves, reached another way, and named as its own reason.

begin(targets: any) → void

Put `targets` (and everything under them) alone on the isolate layer. Returns a token to hand back to `M.restore`, or `(nil, reason)`. The token is returned even when a subject resolves to nothing renderable — restoring it is always safe, which is what lets the caller restore unconditionally.

heldError(token: IsolateToken?, where: string) → string

The reason a frame drawn under `token` does not contain the subject it isolated, or `nil` when every subject was still in the scene and on the layer. A camera under isolation renders the isolate layer and nothing else, so a subject taken off that layer — or out of the scene — while the render was in flight leaves a frame the renderer drew successfully with the subject absent from it. A capture asks this before it accepts the frame, so a picture of a scene that does not exist ends as a stated refusal rather than as the returned path of a written image.

restore(token: IsolateToken?) → void

Undo `M.begin` exactly. Safe to call twice, and safe on a token whose subjects have since despawned. An entity another isolation is still showing keeps the layer: the release that puts it back is the last one holding it, so a capture that ends while a second is mid-render leaves that second one's frame intact.

cameraLayers(baseSpec: string?) → string

The render-layer spec a camera uses to see ONLY the isolated subject. Isolate stops the other geometry drawing and changes nothing else: whatever the capture's own spec said about sky and UI still holds, and its `postProcessing` is untouched, so a final frame stays a final frame. A caller who wants the geometry read flat asks for a pass — that is what passes are for. The subject's layer is added to the pass layers the capture already had, and every other geometry layer is left out by not naming it.