`@bendyline/molen-tooling`

Molen agent tooling: molen CLI and MCP server over a shared ops library.

import { /* … */ } from '@bendyline/molen-tooling';

Interfaces

ApplyUvPaintInput

Properties

dilationPx?

optional dilationPx?: number;

islandMapPath

islandMapPath: string;

Island map (flat-filled islands on a transparent/black background).

maskToIslands?

optional maskToIslands?: boolean;

outPath

outPath: string;

paintedPath

paintedPath: string;

Painted texture (from an image model).

ApplyUvPaintOutput

Properties

error?

optional error?: string;

height?

optional height?: number;

imagePath?

optional imagePath?: string;

ok

ok: boolean;

width?

optional width?: number;

AssetShotInput

Properties

angles?

optional angles?: number;

Number of turntable angles (default 4: front/right/back/left, slightly elevated).

assetVariant?

optional assetVariant?: string;

Render this packed variant (e.g. "ktx2") instead of the canonical main GLB.

clearColor?

optional clearColor?: string;

clip?

optional clip?: string;

Play this clip and pose it at clipTime seconds (default: bind pose).

clipTime?

optional clipTime?: number;

outDir

outDir: string;

projectPath?

optional projectPath?: string;

ref

ref: string;

Project asset id, or a sidecar path.

reflections?

optional reflections?: boolean;

Enable the viewer's shared procedural sky/ground reflection environment.

size?

optional size?: [number, number];

AssetShotOutput

Properties

error?

optional error?: string;

frames?

optional frames?: object[];

name

name: string;

path

path: string;

renderStats?

optional renderStats?: RenderStats;

ok

ok: boolean;

triangles?

optional triangles?: number;

CameraSpec

Properties

lookAt?

optional lookAt?: Vec3;

position

position: Vec3;

CheckTypesOutput

Properties

codegenStale?

optional codegenStale?: boolean;

error?

optional error?: string;

issues?

optional issues?: ValidationIssue[];

ok

ok: boolean;

DiffSnapshotsInput

Properties

a

a: string;

Two keyframe JSON file paths (before, after).

b

b: string;

DiffSnapshotsOutput

Properties

diffs?

optional diffs?: ComponentDiff[];

error?

optional error?: string;

ok

ok: boolean;

DocHit

Properties

design

design: boolean;

excerpt

excerpt: string;

path

path: string;

score

score: number;

DriveAction

Properties

at

at: number;

Tick this action applies at (actions are processed in ascending order).

camera?

optional camera?: CameraSpec;

Camera for this and subsequent frames (default: the scene's camera block).

command?

optional command?: object;

Submit a command (envelope is filled: source "drive", auto seq, tick = at).

payload?

optional payload?: JsonValue;

type

type: string;

screenshot?

optional screenshot?: string;

Capture a named frame once the world reaches this tick.

DriveFrame

Properties

name

name: string;

path

path: string;

renderStats?

optional renderStats?: RenderStats;

tick

tick: number;

DriveInput

Properties

actions

actions: DriveAction[];

assertDoc?

optional assertDoc?: AssertionDoc;

assertPath?

optional assertPath?: string;

assetVariant?

optional assetVariant?: string;

Render packed asset variants (e.g. "ktx2" from molen asset pack) where present.

clearColor?

optional clearColor?: string;

outDir

outDir: string;

Directory frames are written to (<name>.png).

projectPath?

optional projectPath?: string;

scene?

optional scene?: SceneManifest | Record<string, unknown>;

scenePath?

optional scenePath?: string;

setup?

optional setup?: WorldSetup;

setupModule?

optional setupModule?: string;

size?

optional size?: [number, number];

until?

optional until?: number;

Step to this tick after the last action (default: the last action's tick).

DriveOutput

Properties

assertionResults?

optional assertionResults?: AssertionResult[];

assertionsFormatted?

optional assertionsFormatted?: string;

error?

optional error?: string;

events?

optional events?: object[];

payload

payload: JsonValue;

tick

tick: number;

type

type: string;

frames?

optional frames?: DriveFrame[];

ok

ok: boolean;

stateHash?

optional stateHash?: string;

tick?

optional tick?: number;

ExperiencePlayDiagnostic

Properties

actionIndex

actionIndex: number;

kind

kind: "console" | "page-error" | "request-failed";

level?

optional level?: string;

text

text: string;

url?

optional url?: string;

ExperiencePlayFrame

Properties

actionIndex

actionIndex: number;

name

name: string;

path

path: string;

probes

probes: Record<string, string>;

ExperiencePlayInput

Properties

appDir

appDir: string;

Built browser-app directory containing index.html and its static assets.

headed?

optional headed?: boolean;

outDir

outDir: string;

scenario

scenario: 
  | Record<string, unknown>
  | ExperiencePlayScenario;

ExperiencePlayOutput

Properties

diagnostics?

optional diagnostics?: ExperiencePlayDiagnostic[];

error?

optional error?: string;

frames?

optional frames?: ExperiencePlayFrame[];

manifestPath?

optional manifestPath?: string;

ok

ok: boolean;

scenario?

optional scenario?: string;

ExperiencePlayScenario

Properties

actions

actions: ExperiencePlayAction[];

format

format: "molen/experience-play@1";

name

name: string;

path?

optional path?: string;

probes?

optional probes?: object[];

name

name: string;

selector

selector: string;

viewport?

optional viewport?: [number, number];

ExportFramesInput

Properties

assetVariant?

optional assetVariant?: string;

Render packed asset variants (e.g. "ktx2" from molen asset pack) where present.

camera?

optional camera?: CameraSpec;

clearColor?

optional clearColor?: string;

from

from: number;

Inclusive tick range and stride.

outDir

outDir: string;

Directory frames are written to (frame_0000.png, …).

projectPath?

optional projectPath?: string;

Explicit project.json (default: discovered by walking up from the scene).

scene?

optional scene?: SceneManifest | Record<string, unknown>;

scenePath?

optional scenePath?: string;

Scene file path, or a scene NAME from the surrounding project.json.

setup?

optional setup?: WorldSetup;

setupModule?

optional setupModule?: string;

size?

optional size?: [number, number];

step?

optional step?: number;

to

to: number;

track?

optional track?: CameraTrackDoc;

A camera track (inline or path) followed over the range; else a fixed camera.

trackPath?

optional trackPath?: string;

ExportFramesOutput

Properties

dir?

optional dir?: string;

error?

optional error?: string;

frameCount?

optional frameCount?: number;

frames?

optional frames?: string[];

ok

ok: boolean;

FrameRegion

A rectangle as fractions of the frame (0 to 1), so a check reads the same at any size.

Properties

height

height: number;

width

width: number;

x

x: number;

y

y: number;

FrameStats

Properties

background

background: [number, number, number];

The frame's most common color, taken as its backdrop: the clear color or an even sky.

colors

colors: number;

Distinct colors among the measured pixels, each channel quantized to 32 levels.

coverage

coverage: number;

Fraction of the measured pixels that differ from the background by more than tolerance.

height

height: number;

luminance

luminance: number;

Mean of (r + g + b) / 3 over the measured pixels, 0-255.

mean

mean: [number, number, number];

Mean color of the measured pixels.

width

width: number;

FrameStatsOptions

Properties

region?

optional region?: FrameRegion;

Measure only this part of the frame. The background is still the whole frame's.

tolerance?

optional tolerance?: number;

Channel difference above which a pixel counts as content, not background (default 24).

GenerateTypesInput

Properties

check?

optional check?: boolean;

Compare only — exit stale without writing (CI / types check).

cwd?

optional cwd?: string;

out?

optional out?: string;

Override the output path (default: project.codegen.out).

projectPath?

optional projectPath?: string;

GenerateTypesOutput

Properties

componentCount?

optional componentCount?: number;

error?

optional error?: string;

ok

ok: boolean;

outPath?

optional outPath?: string;

scriptArtifacts?

optional scriptArtifacts?: GeneratedScriptArtifact[];

Ambient script types written (or checked) beside each scripts directory.

stale?

optional stale?: boolean;

True when --check found the committed file out of date (or missing).

typeCount?

optional typeCount?: number;

written?

optional written?: boolean;

GetComponentOutput

Properties

description?

optional description?: string;

docsRef?

optional docsRef?: string;

error?

optional error?: string;

examples?

optional examples?: unknown[];

jsonSchema?

optional jsonSchema?: unknown;

name?

optional name?: string;

ok

ok: boolean;

owner?

optional owner?: string;

GetSchemaOutput

Properties

docsRef?

optional docsRef?: string;

error?

optional error?: string;

examples?

optional examples?: unknown[];

id?

optional id?: string;

jsonSchema?

optional jsonSchema?: unknown;

ok

ok: boolean;

GoldenOptions

Properties

maxDiffRatio?

optional maxDiffRatio?: number;

Maximum fraction of differing pixels tolerated (default 0.003).

GoldenResult

Properties

created

created: boolean;

diffRatio?

optional diffRatio?: number;

ok

ok: boolean;

reason?

optional reason?: string;

ImageDiff

Properties

diffPixels

diffPixels: number;

diffRatio

diffRatio: number;

match

match: boolean;

reason?

optional reason?: string;

ImportAssetInput

Properties

assetDir?

optional assetDir?: string;

Exact bundle directory, relative to cwd when not absolute. Mutually exclusive with outDir. Without either override, reimports preserve the project-registered asset directory; new assets use <project dir>/assets/<dotted-id-as-path> (or ./assets without a project).

cwd?

optional cwd?: string;

Directory the discovery starts from (default: process.cwd()).

force?

optional force?: boolean;

Replace files in an existing asset directory. Default false.

id?

optional id?: string;

Asset id (default: slugged filename). Dotted ids fall under namespace reservations.

optimize?

optional optimize?: boolean;

Skip the normalize pass (dedup/prune/weld/quantize).

outDir?

optional outDir?: string;

Output assets root; explicit overrides retain the <root>/<dotted-id-as-path> layout.

path

path: string;

Source model file (.glb / .gltf).

projectPath?

optional projectPath?: string;

Explicit project.json (default: discovered; import still works without one).

trimesh?

optional trimesh?: boolean;

Also extract a whole-asset collision trimesh into collision.bin.

ImportAssetOutput

Properties

dir?

optional dir?: string;

error?

optional error?: string;

id?

optional id?: string;

ok

ok: boolean;

projectPath?

optional projectPath?: string;

The project.json that was (or would have been) updated — always report it.

registered?

optional registered?: boolean;

True when the asset was registered into a project manifest.

sidecar?

optional sidecar?: AssetSidecar;

sidecarPath?

optional sidecarPath?: string;

warnings?

optional warnings?: string[];

InspectAssetInput

Properties

cwd?

optional cwd?: string;

projectPath?

optional projectPath?: string;

ref

ref: string;

Sidecar path, or a project asset id.

verify?

optional verify?: boolean;

Re-hash files.main / collision.bin and compare against the sidecar.

InspectAssetOutput

Properties

error?

optional error?: string;

ok

ok: boolean;

sidecar?

optional sidecar?: AssetSidecar;

sidecarPath?

optional sidecarPath?: string;

verified?

optional verified?: boolean;

verifyErrors?

optional verifyErrors?: string[];

ListAssetsOutput

Properties

assets?

optional assets?: object[];

id

id: string;

kind?

optional kind?: string;

sidecar

sidecar: string;

triangles?

optional triangles?: number;

error?

optional error?: string;

ok

ok: boolean;

ListTemplatesOutput

Properties

error?

optional error?: string;

ok

ok: boolean;

templates

templates: TemplateEntry[];

ListTypesOutput

Properties

error?

optional error?: string;

ok

ok: boolean;

types?

optional types?: object[];

doc?

optional doc?: string;

extends?

optional extends?: string;

id

id: string;

source

source: string;

LoadedScene

Properties

manifest

manifest: SceneManifest;

notices

notices: ValidationIssue[];

Non-fatal advisories from validation (e.g. deprecated_format after a v1 auto-upgrade).

project?

optional project?: ProjectContext;

scenePath

scenePath: string;

LoadSceneOptions

Properties

cwd?

optional cwd?: string;

projectPath?

optional projectPath?: string;

Explicit project.json path; otherwise discovered by walking up from the scene/cwd.

OpDescriptor

Properties

cli?

optional cli?: string;

CLI invocation form, if exposed on the CLI.

mcpTool?

optional mcpTool?: string;

MCP tool name, if exposed over MCP.

name

name: string;

Stable op name (matches the MCP tool name where one exists).

params

params: OpParam[];

summary

summary: string;

OpParam

Properties

cliOnly?

optional cliOnly?: boolean;

True for a parameter that exists only on the CLI — the MCP tool derives it (for example an output directory the tool allocates and returns images from). test/catalog.test.ts requires every other param to match the MCP tool's input schema exactly.

description

description: string;

name

name: string;

required

required: boolean;

type

type: string;

PackAssetInput

Properties

all?

optional all?: boolean;

Pack every asset registered in the project manifest.

cwd?

optional cwd?: string;

etc1sQuality?

optional etc1sQuality?: number;

ETC1S quality 1..255 (default 128).

maxSize?

optional maxSize?: number;

Longest texture side after resizing (default 2048).

mode?

optional mode?: "auto" | PackTextureMode;

Force one codec for every texture; "auto" (default) picks per slot / color space.

powerOfTwo?

optional powerOfTwo?: boolean;

Snap each texture side to the nearest power of two (default true; mip-friendly).

projectPath?

optional projectPath?: string;

ref?

optional ref?: string;

Project asset id, or a sidecar path. Omit with all: true to pack every project asset.

uastcQuality?

optional uastcQuality?: number;

UASTC pack quality 0..4 (default 2; higher is slower and slightly better).

variant?

optional variant?: string;

Variant name recorded in the sidecar (default "ktx2"); the file is model.<variant>.glb.

PackAssetOutput

Properties

assets?

optional assets?: PackedAsset[];

error?

optional error?: string;

ok

ok: boolean;

warnings?

optional warnings?: string[];

PackedAsset

Properties

bytes

bytes: object;

File sizes of the canonical main GLB and the packed variant.

main

main: number;

variant

variant: number;

gpuBytesEstimate

gpuBytesEstimate: object;

Estimated GPU texture memory (with mips) before/after: RGBA8 source vs. 8 bits per texel (ASTC 4x4 / BC7). Real ETC1S transcode targets (BC1/ETC1) are half that on some GPUs.

compressed

compressed: number;

rgba8

rgba8: number;

id

id: string;

path

path: string;

Absolute path of the written variant GLB.

sidecarPath

sidecarPath: string;

textures

textures: PackedTexture[];

variant

variant: string;

PackedTexture

Properties

colorSpace

colorSpace: "srgb" | "linear";

mode

mode: PackTextureMode;

name

name: string;

packed

packed: object;

bytes

bytes: number;

height

height: number;

levels

levels: number;

width

width: number;

slots

slots: string[];

Material slots the texture feeds (e.g. baseColorTexture, normalTexture).

source

source: object;

bytes

bytes: number;

height

height: number;

mimeType

mimeType: string;

width

width: number;

ProjectContext

Properties

componentRegistry

componentRegistry: ComponentRegistry;

content

content: ContentIdentity;

Which pack content the project's worlds are built from; empty without packs.

dir

dir: string;

manifest

manifest: ProjectManifest;

packs

packs: PackSet;

Content packs the project uses (project.json packs, then MOLEN_PACKS).

path

path: string;

resolvedTypes

resolvedTypes: ResolvedTypes;

Flattened type id -> final component map (what the kernel consumes).

typeIssues

typeIssues: ValidationIssue[];

Project-level cross-check issues (duplicates, ownership, dangling refs).

typeScriptFiles

typeScriptFiles: object[];

File-backed scripts declared by registry types, before their paths are inlined.

config

config: JsonObject;

declaration

declaration: string;

file

file: string;

scriptId

scriptId: string;

typeId

typeId: string;

typesDocs

typesDocs: object[];

doc

doc: TypesDoc;

source

source: string;

Methods

resolveScenePath()

resolveScenePath(nameOrPath): string;

Resolve a scene name (from manifest.scenes) or a path into an absolute scene path.

Parameters

nameOrPath

string

Returns

string

ProjectInfoInput

Properties

cwd?

optional cwd?: string;

projectPath?

optional projectPath?: string;

ProjectInfoOutput

Properties

assets?

optional assets?: Record<string, string>;

defaultScene?

optional defaultScene?: string;

error?

optional error?: string;

issues?

optional issues?: ValidationIssue[];

name?

optional name?: string;

ok

ok: boolean;

path?

optional path?: string;

reservations?

optional reservations?: NamespaceReservation[];

scenes?

optional scenes?: Record<string, string>;

setup?

optional setup?: string;

typeIds?

optional typeIds?: string[];

RasterizeInput

Properties

inline?

optional inline?: unknown;

outPath

outPath: string;

Output PNG path for the baseColor slot.

path?

optional path?: string;

Path to a material doc (*.matgraph.json, *.pixelgrid.json, or *.svg) or inline doc.

ref?

optional ref?: string;

Or a "palette:#rrggbb" / "#rrggbb" inline material ref.

size?

optional size?: number;

Optional override size for palette refs / SVG raster width.

RasterizeOutput

Properties

error?

optional error?: string;

height?

optional height?: number;

imagePath?

optional imagePath?: string;

ok

ok: boolean;

slots?

optional slots?: string[];

width?

optional width?: number;

RenderStats

Properties

drawCalls

drawCalls: number;

entitiesRendered

entitiesRendered: number;

triangles

triangles: number;

ReserveNamespaceInput

Properties

cwd?

optional cwd?: string;

namespace

namespace: string;

note?

optional note?: string;

owner

owner: string;

projectPath?

optional projectPath?: string;

ReserveNamespaceOutput

Properties

alreadyReserved?

optional alreadyReserved?: boolean;

True when the same owner already held the namespace (no-op).

conflict?

optional conflict?: NamespaceReservation;

Set on conflict: who holds the overlapping namespace.

error?

optional error?: string;

ok

ok: boolean;

reservations?

optional reservations?: NamespaceReservation[];

RunReplayInput

Properties

path

path: string;

Path to a *.replay.json fixture.

projectPath?

optional projectPath?: string;

Explicit project.json for the fixture's scene (default: discovered from the scene path).

record?

optional record?: boolean;

Regenerate expected.stateHash + expected.tickHashes from the current build and write them back to the fixture (run after an intentional engine/content change).

setupModule?

optional setupModule?: string;

Module providing systems + command handlers (default/named setup).

RunReplayOutput

Properties

actualEventCount?

optional actualEventCount?: number;

actualHash?

optional actualHash?: string;

deterministic?

optional deterministic?: boolean;

True when the build reproduces itself run-to-run (only checked on a hash mismatch).

diff?

optional diff?: ComponentDiff[];

Component-level diff at the divergent tick (available for non-deterministic builds).

divergence?

optional divergence?: "non-deterministic" | "behavior-drift";

Classifies a mismatch so the fix is obvious.

error?

optional error?: string;

Set when something failed before running (bad fixture/scene).

expectedEventCount?

optional expectedEventCount?: number;

expectedHash?

optional expectedHash?: string;

firstDivergentTick?

optional firstDivergentTick?: number;

First tick at which state diverged (from the self-determinism check or tickHashes).

ok

ok: boolean;

report?

optional report?: string;

Agent-facing summary of what happened and what to do.

ticks?

optional ticks?: number;

ScaffoldInput

Properties

dir?

optional dir?: string;

Parent directory (default: cwd).

force?

optional force?: boolean;

Replace scaffold-owned files that already exist. Default false.

name

name: string;

Experience name; also the output folder name and the type namespace.

template?

optional template?: string;

Copy a shipped sample instead of the built-in starter: a template id from listTemplates() (molen templates), e.g. cubes or top-down-arena.

ScaffoldOutput

Properties

dir?

optional dir?: string;

error?

optional error?: string;

files?

optional files?: string[];

nextSteps?

optional nextSteps?: string[];

ok

ok: boolean;

ScreenshotInput

Properties

assetVariant?

optional assetVariant?: string;

Render packed asset variants (e.g. "ktx2" from molen asset pack) where present.

camera?

optional camera?: CameraSpec;

clearColor?

optional clearColor?: string;

Background clear color; defaults to sky-blue with terrain, else dark.

outPath

outPath: string;

projectPath?

optional projectPath?: string;

Explicit project.json (default: discovered by walking up from the scene).

reflections?

optional reflections?: boolean;

Enable the viewer's shared procedural sky/ground reflections for PBR metals and glass.

scene?

optional scene?: SceneManifest | Record<string, unknown>;

A full manifest or any raw scene doc (it is validated and defaulted internally).

scenePath?

optional scenePath?: string;

Scene file path, or a scene NAME from the surrounding project.json.

setup?

optional setup?: WorldSetup;

setupModule?

optional setupModule?: string;

size?

optional size?: [number, number];

terrain?

optional terrain?: TerrainShot;

ticks

ticks: number;

ScreenshotOutput

Properties

error?

optional error?: string;

imagePath?

optional imagePath?: string;

ok

ok: boolean;

renderStats?

optional renderStats?: RenderStats;

stateHash?

optional stateHash?: string;

tick?

optional tick?: number;

ScriptDiagnostic

Properties

code

code: string;

column

column: number;

file

file: string;

Project-relative script path.

line

line: number;

message

message: string;

SearchDocsInput

Properties

baseDir?

optional baseDir?: string;

Override the base dir to search from (defaults to the located bundle root).

includeDesign?

optional includeDesign?: boolean;

Also search the historical design plan in docs/, which may lag the code. Off by default — those hits describe intent, not the shipped engine. When on, they are tagged.

k?

optional k?: number;

query

query: string;

SearchDocsOutput

Properties

formatted

formatted: string;

hits

hits: DocHit[];

ok

ok: boolean;

root?

optional root?: string;

SimulateInput

Extended by

SimWatchInput

Properties

assertDoc?

optional assertDoc?: AssertionDoc;

assertPath?

optional assertPath?: string;

commands?

optional commands?: Command[];

commandsPath?

optional commandsPath?: string;

projectPath?

optional projectPath?: string;

Explicit project.json (default: discovered by walking up from the scene).

scene?

optional scene?: SceneManifest;

scenePath?

optional scenePath?: string;

Scene file path, or a scene NAME from the surrounding project.json.

setup?

optional setup?: WorldSetup;

Programmatic setup (systems + command handlers); takes precedence over setupModule.

setupModule?

optional setupModule?: string;

Path to a module exporting setup(world, manifest) or a defineExperience(...) result.

ticks

ticks: number;

SimulateOutput

Properties

ambient?

optional ambient?: object;

Ambient life at the final tick, when the scene has an ambient block.

agents

agents: Record<string, number>;

despawned

despawned: number;

lanes

lanes: number;

spawned

spawned: number;

assertionResults

assertionResults: AssertionResult[];

assertionsFormatted?

optional assertionsFormatted?: string;

content?

optional content?: ContentIdentity;

The pack content the world was built from (project.json packs, MOLEN_PACKS).

error?

optional error?: string;

Set when something failed before running (bad scene, etc.).

eventCount

eventCount: number;

events

events: RecordedEvent[];

notices?

optional notices?: ValidationIssue[];

Non-fatal advisories (e.g. deprecated scene format).

ok

ok: boolean;

physics?

optional physics?: "none" | "kinematics" | "platformer" | "rapier";

The scene's physics engine, when declared (kinematics = cross-platform deterministic).

stateHash

stateHash: string;

tick

tick: number;

SimWatchHandle

Methods

close()

close(): void;

Returns

void

SimWatchInput

Extends

SimulateInput

Properties

assertDoc?

optional assertDoc?: AssertionDoc;

Inherited from

SimulateInput.assertDoc

assertPath?

optional assertPath?: string;

Inherited from

SimulateInput.assertPath

commands?

optional commands?: Command[];

Inherited from

SimulateInput.commands

commandsPath?

optional commandsPath?: string;

Inherited from

SimulateInput.commandsPath

projectPath?

optional projectPath?: string;

Explicit project.json (default: discovered by walking up from the scene).

Inherited from

SimulateInput.projectPath

scene?

optional scene?: SceneManifest;

Inherited from

SimulateInput.scene

scenePath?

optional scenePath?: string;

Scene file path, or a scene NAME from the surrounding project.json.

Inherited from

SimulateInput.scenePath

setup?

optional setup?: WorldSetup;

Programmatic setup (systems + command handlers); takes precedence over setupModule.

Inherited from

SimulateInput.setup

setupModule?

optional setupModule?: string;

Path to a module exporting setup(world, manifest) or a defineExperience(...) result.

Inherited from

SimulateInput.setupModule

ticks

ticks: number;

Inherited from

SimulateInput.ticks

watchPaths?

optional watchPaths?: string[];

Extra files/directories to watch (transitive project/scene inputs are automatic).

Methods

onRun()

onRun(result, diff): void;

Called after every completed run with the result + a diff line against the previous run.

Parameters

result

SimulateOutput

diff

string

Returns

void

StageAssetsInput

Properties

clean?

optional clean?: boolean;

Remove a previous staging output first (only a directory holding assets.index.json).

cwd?

optional cwd?: string;

outDir

outDir: string;

Output directory (created).

projectPath?

optional projectPath?: string;

requireVariant?

optional requireVariant?: boolean;

Require the variant on every asset instead of falling back to the main file.

variant?

optional variant?: string;

Prefer this packed variant (e.g. "ktx2"); assets without it stage their main file.

StageAssetsOutput

Properties

assets?

optional assets?: StagedAsset[];

error?

optional error?: string;

index?

optional index?: Record<string, string>;

indexPath?

optional indexPath?: string;

ok

ok: boolean;

outDir?

optional outDir?: string;

warnings?

optional warnings?: string[];

StagedAsset

Properties

bytes

bytes: number;

file

file: string;

Staged model URL relative to outDir (also the index entry).

id

id: string;

variant?

optional variant?: string;

The variant that was staged, when one was.

TemplateEntry

Properties

description

description: string;

One line on what the sample shows.

id

id: string;

Template id: the sample's directory name in the engine repository (e.g. cubes).

TestTypesInput

Properties

cwd?

optional cwd?: string;

only?

optional only?: string[];

Only test these type ids (default: all).

projectPath?

optional projectPath?: string;

ticks?

optional ticks?: number;

Ticks to simulate each type for (default 30).

TestTypesOutput

Properties

error?

optional error?: string;

ok

ok: boolean;

results?

optional results?: TypeTestResult[];

TypeTestResult

Properties

error?

optional error?: string;

id

id: string;

issues?

optional issues?: ValidationIssue[];

ok

ok: boolean;

ValidateInput

Properties

inline?

optional inline?: unknown;

kind?

optional kind?: string;

Force a schema kind (any registered kind); otherwise detected from the envelope.

path?

optional path?: string;

Path to a JSON document, or inline data. One of the two is required.

projectPath?

optional projectPath?: string;

Explicit project.json giving a scene its registry types (default: discovered by walking up from path). With a project, entity/prefab type references are checked too.

verifyFiles?

optional verifyFiles?: boolean;

For terrain-package files, stream-check declared paths, sizes, and SHA-256 hashes.

ValidateOutput

Properties

formatted?

optional formatted?: string;

Present when not ok: the agent-facing formatted error block.

issues?

optional issues?: unknown[];

kind?

optional kind?: string;

ok

ok: boolean;

value?

optional value?: unknown;

Present when ok: the parsed (defaults-applied) value.

verifiedFiles?

optional verifiedFiles?: number;

WorldgenBakeInput

Properties

batchPath?

optional batchPath?: string;

A molen/worldgen-batch@1 document; or give outline (+ styleId) for one building.

force?

optional force?: boolean;

Replace an existing asset directory.

ground?

optional ground?: "flat" | "slope";

id?

optional id?: string;

Asset id (default: the batch name, slugged).

outDir

outDir: string;

Assets root the baked asset directory is created under.

outline?

optional outline?: string;

"x,z;x,z;..." in meters, one building.

packPath?

optional packPath?: string;

Style pack manifest or directory (default: the shipped default pack).

projectPath?

optional projectPath?: string;

styleId?

optional styleId?: string;

Force every building onto this style id (required with outline).

WorldgenBakeOutput

Properties

dir?

optional dir?: string;

error?

optional error?: string;

glbBytes?

optional glbBytes?: number;

hash?

optional hash?: string;

id?

optional id?: string;

ok

ok: boolean;

placements?

optional placements?: object[];

Instanced placements the mesh does not contain (roof props, scatter).

count

count: number;

modelRef

modelRef: string;

sidecar?

optional sidecar?: AssetSidecar;

sidecarPath?

optional sidecarPath?: string;

stats?

optional stats?: WorldgenStats;

warnings?

optional warnings?: string[];

WorldgenPreviewInput

Properties

angles?

optional angles?: number;

Turntable angles (default 1).

batchPath?

optional batchPath?: string;

A molen/worldgen-batch@1 document (default: the built-in lineup of every shape class).

clearColor?

optional clearColor?: string;

ground?

optional ground?: "flat" | "slope";

outPath

outPath: string;

PNG path; with several angles the index is appended before the extension.

packPath?

optional packPath?: string;

Style pack manifest or directory (default: the shipped default pack).

scatterId?

optional scatterId?: string;

size?

optional size?: [number, number];

styleId?

optional styleId?: string;

Force every building onto this style id (default: the pack's own rules).

stylePath?

optional stylePath?: string;

A standalone molen/archstyle@1 document to preview (injected into the pack).

WorldgenPreviewOutput

Properties

error?

optional error?: string;

frames?

optional frames?: WorldgenPreviewFrame[];

hash?

optional hash?: string;

materialFailures?

optional materialFailures?: string[];

Material references the page could not bake (rendered flat).

ok

ok: boolean;

renderStats?

optional renderStats?: WorldgenPreviewRenderStats;

stats?

optional stats?: WorldgenStats;

WorldgenStatsInput

Properties

atlasPath?

optional atlasPath?: string;

auto?

optional auto?: boolean;

Search the 9x9 tiles around the center for the one with the most buildings.

dumpPath?

optional dumpPath?: string;

Write the adapted batch document here.

packagePath

packagePath: string;

terrain-package.json path.

packPath?

optional packPath?: string;

quality?

optional quality?: WorldgenQualityPreset;

styleId?

optional styleId?: string;

Force every building onto this style id.

tile?

optional tile?: string;

"z/x/y" tile address; omit to use the tile at the package center (auto searches around it).

WorldgenStatsOutput

Properties

buildingsWithoutIds?

optional buildingsWithoutIds?: number;

Buildings whose identity came from a quantized centroid (no feature id in the source).

clippedPieces?

optional clippedPieces?: number;

deterministic?

optional deterministic?: boolean;

dumpPath?

optional dumpPath?: string;

error?

optional error?: string;

generateMs?

optional generateMs?: object;

first

first: number;

second

second: number;

hash?

optional hash?: string;

ok

ok: boolean;

placements?

optional placements?: object[];

count

count: number;

modelRef

modelRef: string;

region?

optional region?: string;

scatter?

optional scatter?: string;

skippedByOwnership?

optional skippedByOwnership?: number;

source?

optional source?: object;

buildings

buildings: number;

landcover

landcover: number;

roads

roads: number;

water

water: number;

stats?

optional stats?: WorldgenStats;

tile?

optional tile?: object;

level

level: number;

x

x: number;

y

y: number;

warnings?

optional warnings?: string[];

Type Aliases

ExperiencePlayAction

type ExperiencePlayAction = ExperiencePlayActionBase & 
  | {
  durationMs: number;
  type: "wait";
}
  | {
  selector: string;
  text?: string;
  timeoutMs?: number;
  type: "wait-for";
}
  | {
  selector: string;
  stableMs?: number;
  text?: string;
  timeoutMs?: number;
  type: "wait-for-stable";
}
  | {
  durationMs: number;
  keys: string[];
  type: "keys";
}
  | {
  keys: string[];
  type: "key-down";
}
  | {
  keys: string[];
  type: "key-up";
}
  | {
  durationMs?: number;
  from: [number, number];
  selector: string;
  steps?: number;
  to: [number, number];
  type: "drag";
}
  | {
  selector: string;
  type: "click";
}
  | {
  selector: string;
  type: "select";
  value: string;
}
  | {
  path: string;
  type: "navigate";
}
  | {
  fullPage?: boolean;
  name: string;
  settleMs?: number;
  timeoutMs?: number;
  type: "screenshot";
};

PackTextureMode

type PackTextureMode = "etc1s" | "uastc";

Variables

ASSET_INDEX_FILE

const ASSET_INDEX_FILE: "assets.index.json" = "assets.index.json";

OPS_CATALOG

const OPS_CATALOG: OpDescriptor[];

Machine-readable contract for every agent-facing operation. The CLI help and the MCP describe_op tool both render this, so an agent can discover I/O without reading source.

TOOLING_PACKAGE

const TOOLING_PACKAGE: "@bendyline/molen-tooling" = "@bendyline/molen-tooling";

Functions

applyUvPaintOp()

function applyUvPaintOp(input): Promise<ApplyUvPaintOutput>;

Import a painted UV template: mask it to the island map and dilate the gutters (docs-src/guide/materials.md, "Rung 5 — UV paint-by-numbers"). The MCP apply_uv_paint tool. (Template/sidecar generation from a mesh via xatlas is a separate, heavier Node toolchain step.)

Parameters

input

ApplyUvPaintInput

Returns

Promise<ApplyUvPaintOutput>

assetFileIndex()

function assetFileIndex(project, opts?): Promise<Record<string, string>>;

Resolve asset ids to their sidecar-declared primary files for browser renderers. With variant, a packed variant (molen asset pack) replaces the main file where present.

Parameters

project

ProjectContext

opts?

variant?

string

Returns

Promise<Record<string, string>>

bakeWorldgen()

function bakeWorldgen(input): Promise<WorldgenBakeOutput>;

Parameters

input

WorldgenBakeInput

Returns

Promise<WorldgenBakeOutput>

buildContentPack()

function buildContentPack(input): Promise<BuildPackOutput>;

Parameters

input

BuildPackInput

Returns

Promise<BuildPackOutput>

checkScripts()

function checkScripts(input): Promise<CheckScriptsOutput>;

Typecheck every file-backed scene or registry-type script in the project.

Parameters

input

CheckScriptsInput

Returns

Promise<CheckScriptsOutput>

checkTypesOp()

function checkTypesOp(input): Promise<CheckTypesOutput>;

Parameters

input

ProjectInfoInput

Returns

Promise<CheckTypesOutput>

compareGolden()

function compareGolden(
   candidatePath, 
   goldenPath, 
   diffPath, 
   opts?
): Promise<GoldenResult>;

Compare a freshly rendered candidate PNG against a committed golden. Records the golden only when UPDATE_GOLDENS=1. Tolerance: per-pixel threshold 0.1, max maxDiffRatio differing pixels (default 0.3%).

A missing golden fails. Silently adopting the candidate would make "this test has no reference image" indistinguishable from "this test passed" — and in a fresh CI checkout every uncommitted golden would take that branch, so a suite could report green while comparing nothing.

Parameters

candidatePath

string

goldenPath

string

diffPath

string

opts?

GoldenOptions

Returns

Promise<GoldenResult>

describeOps()

function describeOps(name?): OpDescriptor[];

Return the full catalog, or just the entry whose name/cli/mcpTool matches name.

Parameters

name?

string

Returns

OpDescriptor[]

diffImages()

function diffImages(
   aPath, 
   bPath, 
   diffPath, 
   maxDiffRatio?
): Promise<ImageDiff>;

Pixel-diff two PNGs; writes a diff image. Per-pixel threshold 0.1.

Parameters

aPath

string

bPath

string

diffPath

string

maxDiffRatio?

number

Returns

Promise<ImageDiff>

diffSnapshots()

function diffSnapshots(input): Promise<DiffSnapshotsOutput>;

Diff two keyframe snapshots at the component level.

Parameters

input

DiffSnapshotsInput

Returns

Promise<DiffSnapshotsOutput>

driveScene()

function driveScene(input): Promise<DriveOutput>;

Drive a scene: commands in, frames out, deterministically.

Parameters

input

DriveInput

Returns

Promise<DriveOutput>

exportFrames()

function exportFrames(input): Promise<ExportFramesOutput>;

Render a sequence of frames over a tick range, optionally following a camera track (machinima). Builds the world once and steps incrementally so every frame is from the same timeline.

Parameters

input

ExportFramesInput

Returns

Promise<ExportFramesOutput>

extractContentPack()

function extractContentPack(input): Promise<ExtractPackOutput>;

Parameters

input

ExtractPackInput

Returns

Promise<ExtractPackOutput>

fetchContentPack()

function fetchContentPack(input): Promise<FetchPackOutput>;

Download packs into a project so it runs offline, and pin them in project.json packs with their contentHash. Nothing is fetched implicitly anywhere else: this is the explicit step.

Parameters

input

FetchPackInput

Returns

Promise<FetchPackOutput>

findProjectFile()

function findProjectFile(startDir): Promise<string | undefined>;

Walk from startDir up to the fs root looking for a project.json with the right envelope.

Parameters

startDir

string

Returns

Promise<string | undefined>

formatOp()

function formatOp(op): string;

Render one descriptor as agent-facing help text.

Parameters

op

OpDescriptor

Returns

string

frameStats()

function frameStats(path, options?): Promise<FrameStats>;

Measure a rendered frame without a reference image: how much of it is content, how varied it is, and its mean color, for the whole frame or a region. Checks built on these (the frame is not blank, the model covers its part of the view, a lit room is brighter than an unlit one) hold on any machine, where a pixel comparison needs a reference recorded on the machine that compares.

Parameters

path

string

options?

FrameStatsOptions

Returns

Promise<FrameStats>

generateTypes()

function generateTypes(input): Promise<GenerateTypesOutput>;

Generate (or verify with check) the project's typed component/type-id module.

Parameters

input

GenerateTypesInput

Returns

Promise<GenerateTypesOutput>

getComponentOp()

function getComponentOp(name, registry?): GetComponentOutput;

Get one component's schema + examples.

Parameters

name

string

registry?

ComponentRegistry

Returns

GetComponentOutput

getSchemaOp()

function getSchemaOp(kind): GetSchemaOutput;

Get one schema kind: JSON Schema + examples + docs reference.

Parameters

kind

string

Returns

GetSchemaOutput

importAsset()

function importAsset(input): Promise<ImportAssetOutput>;

Import a glTF/GLB into the project's asset store: validate + normalize (dedup/prune/weld/ quantize; Draco always decoded, never re-encoded — the canonical GLB needs no external decoders), extract bounds + per-node convex hulls (+ optional whole-asset trimesh) for headless physics, write the molen/asset@1 sidecar, and register into project.json.

Parameters

input

ImportAssetInput

Returns

Promise<ImportAssetOutput>

inspectAsset()

function inspectAsset(input): Promise<InspectAssetOutput>;

Read + validate a sidecar (by path or project asset id); optionally verify file hashes.

Parameters

input

InspectAssetInput

Returns

Promise<InspectAssetOutput>

inspectContentPack()

function inspectContentPack(input): Promise<InspectPackOutput>;

Parameters

input

InspectPackInput

Returns

Promise<InspectPackOutput>

lineupBatchDoc()

function lineupBatchDoc(spacing?): WorldgenBatchDoc;

One of each footprint class in a row along +x (40 m apart), generic labels, flat ground.

Parameters

spacing?

number

Returns

WorldgenBatchDoc

listAssets()

function listAssets(input): Promise<ListAssetsOutput>;

List the assets registered in the surrounding project.

Parameters

input

cwd?

string

projectPath?

string

Returns

Promise<ListAssetsOutput>

listComponentsOp()

function listComponentsOp(registry?): ComponentSummary[];

List the known component vocabulary (name + description + owning layer).

Parameters

registry?

ComponentRegistry

Returns

ComponentSummary[]

listSchemasOp()

function listSchemasOp(): SchemaSummary[];

List every registered asset schema kind.

Returns

SchemaSummary[]

listTemplates()

function listTemplates(): Promise<ListTemplatesOutput>;

The sample templates molen new --template <id> can scaffold.

Returns

Promise<ListTemplatesOutput>

listTypes()

function listTypes(input): Promise<ListTypesOutput>;

Parameters

input

ProjectInfoInput

Returns

Promise<ListTypesOutput>

loadProject()

function loadProject(path): Promise<ProjectContext>;

Load + validate a project manifest and every types document it references. Throws on invalid.

Parameters

path

string

Returns

Promise<ProjectContext>

loadSceneDocument()

function loadSceneDocument(ref, opts?): Promise<LoadedScene>;

Load a scene by path or by project scene name: validate (legacy versions auto-upgrade), resolve scripts[].path file refs into inline code (scene-file-relative), and thread the surrounding project (for registry types). Throws with a formatted message on invalid input.

Parameters

ref

string

opts?

LoadSceneOptions

Returns

Promise<LoadedScene>

loadSetupLike()

function loadSetupLike(modulePath): Promise<WorldSetup>;

Load a setup module: accepts export default setup, export setup, or a defineExperience result.

Parameters

modulePath

string

Returns

Promise<WorldSetup>

loadStylePackFromDisk()

function loadStylePackFromDisk(packPath?, options?): Promise<LoadedStylePackFiles>;

Load a style pack from packPath (a stylepack.json, a directory holding one, a content pack file, URL or source directory) or, without one, from the content packs the project uses.

Parameters

packPath?

string

options?

PackOptions

Returns

Promise<LoadedStylePackFiles>

locateDocsRoot()

function locateDocsRoot(start?): Promise<string>;

Locate the docs bundle root by walking up from a start dir until a folder containing docs-src/llms.txt is found. Falls back to the start dir. This makes search_docs work regardless of the cwd the MCP server / CLI was launched from.

Parameters

start?

string

Returns

Promise<string>

packAsset()

function packAsset(input): Promise<PackAssetOutput>;

Pack one or every project asset into a KTX2 runtime variant (see module comment).

Parameters

input

PackAssetInput

Returns

Promise<PackAssetOutput>

parseExperiencePlayScenario()

function parseExperiencePlayScenario(value): ExperiencePlayScenario;

Parameters

value

| Record<string, unknown> | ExperiencePlayScenario

Returns

ExperiencePlayScenario

playExperience()

function playExperience(input): Promise<ExperiencePlayOutput>;

Play a built browser experience: browser inputs in, screenshots and diagnostics out.

Parameters

input

ExperiencePlayInput

Returns

Promise<ExperiencePlayOutput>

previewWorldgen()

function previewWorldgen(input): Promise<WorldgenPreviewOutput>;

Parameters

input

WorldgenPreviewInput

Returns

Promise<WorldgenPreviewOutput>

projectInfo()

function projectInfo(input): Promise<ProjectInfoOutput>;

Parameters

input

ProjectInfoInput

Returns

Promise<ProjectInfoOutput>

rasterizeMaterial()

function rasterizeMaterial(input): Promise<RasterizeOutput>;

Bake a material (graph or palette) to a PNG. The MCP rasterize_material tool.

Parameters

input

RasterizeInput

Returns

Promise<RasterizeOutput>

registerExperiencePlaySchema()

function registerExperiencePlaySchema(): void;

Returns

void

renderTypesModule()

function renderTypesModule(project): string;

Render the generated module (deterministic given the registry + project types).

Parameters

project

ProjectContext

Returns

string

reserveNamespace()

function reserveNamespace(input): Promise<ReserveNamespaceOutput>;

Parameters

input

ReserveNamespaceInput

Returns

Promise<ReserveNamespaceOutput>

runReplayFile()

function runReplayFile(input): Promise<RunReplayOutput>;

Replay a recorded fixture and compare the final state hash. On a mismatch, localize the divergence instead of just reporting "hash differs":

re-run the build against itself — if it diverges from itself, the build is NON-DETERMINISTIC; report the first divergent tick + a component-level diff.
otherwise the build is deterministic but its result drifted from the recording (an intentional engine/content change, or a regression). If the fixture stored per-tick hashes, report the first tick that differs from the recording.

Parameters

input

RunReplayInput

Returns

Promise<RunReplayOutput>

runSimulation()

function runSimulation(input): Promise<SimulateOutput>;

Run a scene headlessly for N ticks, applying commands and evaluating assertions.

Parameters

input

SimulateInput

Returns

Promise<SimulateOutput>

scaffoldExperience()

function scaffoldExperience(input): Promise<ScaffoldOutput>;

Scaffold a complete, runnable project: the built-in starter (manifest + scene + types + scripts

setup + browser app), or with template a copy of one of the shipped samples. Either way the project gets an AGENTS.md pointing a coding agent at the version-locked docs and its loop.

Parameters

input

ScaffoldInput

Returns

Promise<ScaffoldOutput>

schemaToTsType()

function schemaToTsType(schema, indent?): string;

Print a JSON Schema node as a TS type expression. Unknown constructs degrade to unknown.

Parameters

schema

unknown

indent?

string

Returns

string

screenshotAsset()

function screenshotAsset(input): Promise<AssetShotOutput>;

Render turntable views of an imported asset.

Parameters

input

AssetShotInput

Returns

Promise<AssetShotOutput>

screenshotScene()

function screenshotScene(input): Promise<ScreenshotOutput>;

Simulate a scene to tick N in Node, serialize a keyframe, then render exactly one deterministic frame in headless Chromium (SwiftShader) and save a PNG with a stats block (docs-src/guide/agent-loop.md, "Screenshot"). The capture page boots a snapshot viewer — no live kernel. gltf renderables are served to the page over an ephemeral localhost HTTP server.

Parameters

input

ScreenshotInput

Returns

Promise<ScreenshotOutput>

searchDocs()

function searchDocs(input): Promise<SearchDocsOutput>;

Lexical doc search (term-frequency ranking) over the shipped bundle.

Parameters

input

SearchDocsInput

Returns

Promise<SearchDocsOutput>

simWatch()

function simWatch(input): Promise<SimWatchHandle>;

Run once, then rerun (debounced) on every change to any transitive input.

Parameters

input

SimWatchInput

Returns

Promise<SimWatchHandle>

stageAssets()

function stageAssets(input): Promise<StageAssetsOutput>;

Stage registered assets (+ optional packed variant) into a browser-servable directory.

Parameters

input

StageAssetsInput

Returns

Promise<StageAssetsOutput>

testTypes()

function testTypes(input): Promise<TestTypesOutput>;

Spawn + simulate every registry type in isolation; report per-type verdicts.

Parameters

input

TestTypesInput

Returns

Promise<TestTypesOutput>

updateProjectFile()

Call Signature

function updateProjectFile(path, mutate): Promise<ProjectManifest>;

The single write path for project.json: lockfile (O_EXCL, stale after 30s, bounded retry), re-read, mutate, validate, write temp + atomic rename. Concurrent agents (asset import, types reserve) serialize here instead of clobbering each other.

Parameters

path

string

mutate

(manifest) => void

Returns

Promise<ProjectManifest>

Call Signature

function updateProjectFile(path, mutate): Promise<ProjectManifest>;

Parameters

path

string

mutate

(manifest) => ProjectManifest

Returns

Promise<ProjectManifest>

validateAsset()

function validateAsset(input): Promise<ValidateOutput>;

Validate an asset document against its schema (kind auto-detected when omitted).

Parameters

input

ValidateInput

Returns

Promise<ValidateOutput>

verifyContentPack()

function verifyContentPack(input): Promise<VerifyPackOutput>;

Read every file (checking CRC and sha256), validate each JSON document whose format is a registered schema, and check that asset sidecars' hashes match their models.

Parameters

input

InspectPackInput

Returns

Promise<VerifyPackOutput>

worldgenStats()

function worldgenStats(input): Promise<WorldgenStatsOutput>;

Parameters

input

WorldgenStatsInput

Returns

Promise<WorldgenStatsOutput>

@bendyline/molen-tooling ​

Interfaces ​

ApplyUvPaintInput ​

Properties ​

dilationPx? ​

islandMapPath ​

maskToIslands? ​

outPath ​

paintedPath ​

ApplyUvPaintOutput ​

Properties ​

error? ​

height? ​

imagePath? ​

ok ​

width? ​

AssetShotInput ​

Properties ​

angles? ​

assetVariant? ​

clearColor? ​

clip? ​

clipTime? ​

outDir ​

projectPath? ​

ref ​

reflections? ​

size? ​

AssetShotOutput ​

Properties ​

error? ​

frames? ​

name ​

path ​

renderStats? ​

ok ​

triangles? ​

CameraSpec ​

Properties ​

lookAt? ​

position ​

CheckTypesOutput ​

Properties ​

codegenStale? ​

error? ​

issues? ​

ok ​

DiffSnapshotsInput ​

Properties ​

a ​

b ​

DiffSnapshotsOutput ​

Properties ​

diffs? ​

error? ​

ok ​

DocHit ​

Properties ​

design ​

excerpt ​

path ​

score ​

DriveAction ​

Properties ​

at ​

camera? ​

command? ​

payload? ​

type ​

screenshot? ​

DriveFrame ​

Properties ​

name ​

path ​

renderStats? ​

tick ​

DriveInput ​

Properties ​

actions ​

assertDoc? ​

`@bendyline/molen-tooling`

Interfaces

ApplyUvPaintInput

Properties

dilationPx?

islandMapPath

maskToIslands?

outPath

paintedPath

ApplyUvPaintOutput

Properties

error?

height?

imagePath?

ok

width?

AssetShotInput

Properties

angles?

assetVariant?

clearColor?

clip?

clipTime?

outDir

projectPath?

ref

reflections?

size?

AssetShotOutput

Properties

error?

frames?

name

path

renderStats?

ok

triangles?

CameraSpec

Properties

lookAt?

position

CheckTypesOutput

Properties

codegenStale?

error?

issues?

ok

DiffSnapshotsInput

Properties

a

b

DiffSnapshotsOutput

Properties

diffs?

error?

ok

DocHit

Properties

design

excerpt

path

score

DriveAction

Properties

at

camera?

command?

payload?

type

screenshot?

DriveFrame

Properties

name

path

renderStats?

tick

DriveInput

Properties

actions

assertDoc?