Wetware World

Application

The WWD Workbench

One window over a package: a model tree, a viewport, a properties table and a validation dock. Author against the registry, validate with the reference implementation, place a mechanism, run it, write the study into the file, reopen it.

Modes
2
Palette parts
6
Interactions
53
Test suites
6

Definition

The WWD Workbench is a local application that opens a .wwd package, authors its design against the Core property registry, validates it with the reference validator, simulates a tissue driving a mechanism, writes the study back into the package, and exports the package again. It runs in a browser against a loopback bridge to the reference validator. Its four panes are a model tree, a 3D viewport, a properties table and a validation dock. A property authored from the registry carries the registry causal role, and the workbench refuses to bind a response as a control. Every number the simulation engine produces is written with provenance simulated.

The workbench is one application over one file. Design mode edits the article: the component, its frame and named dimensions, the biology, the property fields, the interfaces and the acceptance criteria. Play mode places that article among mechanism parts, connects ports into nets, runs the engine, and writes the study back into the package.

Validation is not a separate step at the end. The validation dock runs the reference implementation over the package bytes and reports conformance findings in one table and design rules in a second table beside them.

The panes

What each region of the window holds.

The workbench window
Pane Where Contents
Model treeleft pane, Design modeThe package as a tree: component, frame, dimensions, validity window, regions, biology, fields, interfaces, acceptance criteria, results. Each field row shows its causal role beside its name.
Assemblyleft pane, Play modeThe mechanism palette, the placed parts with their stated parameters, the nets between ports, and the assembly rule check.
Viewportcentre paneA 3D view. In Design mode it draws an axis-aligned box from the named dimensions and states what it did not draw. In Play mode it draws the assembly and reports the part count, the net count and the sample index.
Propertiesright paneA dense table for the selected node. Values are edited as quantity strings with the unit shown. Registry facts, property, quantity kind, canonical unit, value shape, causal role and definition, are displayed rather than offered as a choice.
Validation dockbottom paneSix tabs: Validation, Study, Acceptance, Causal projection, Manifest, Source. Validation lists conformance findings and design rules in separate tables.

The title bar carries the open file name, the validator identity and the registry sync stamp, so a package authored against a stale registry is visible rather than inferred.

Authoring against the registry

Where the causal role comes from.

A property added from the Core registry arrives with its quantity kind, its canonical unit, its value shape, its definition and its causal role already fixed. The properties table displays the causal role. It is not a select.

What the properties panel shows for a registry term
Row Where the value comes from On screen for the twitch-force term
propertyfrom the registry pickerwwd:peak_twitch_force
quantity kindfixed by the registry termforce
canonical unitfixed by the registry termuN
value shapefixed by the registry termscalar
causal roletaken from the registry, not offered as a choiceresponse
definitionthe registry definition, on screen while authoringPeak force of a single twitch contraction under a stated stimulation protocol.
referencethe registry reference for the terma published validation range for twitch force in engineered human muscle
The WWD Workbench in Design mode. The properties panel on the right shows the registry term wwd:peak_twitch_force with quantity kind force, canonical unit uN, value shape scalar, and causal role response marked as taken from the registry and not offered as a choice. Below it a red notice says the property is a response, that it will be bound as a response and the workbench will not let it be a control, naming A8_RESPONSE_IMPOSED and V03_CAUSAL_CLASS_MISMATCH, followed by a single button reading bind it as a response. The model tree on the left lists the component, frame, dimensions, regions, biology, fields and interfaces. The validation dock at the bottom shows the status valid with 0 errors and 2 warnings, a conformance findings table with two N08_NO_OPERATING_LIMITS warnings on the two attachment-loop interfaces, and a separate design rules table listing DFM-001 on tissue thickness and diffusion depth, DFM-010 on a missing validity window and DFM-012 on unknown commercial derivative rights.
The refusal is stated before anything is written, names the diagnostics an imposed response would earn, and offers one button that binds the property as a response.
The properties panel editing wwd:matrix_formulation, with a what it is made of table holding two constituents, fibrin at 0.7 and matrigel at 0.5, an add a constituent button and a scale to sum 1 button. A red line under the table reads sum 1.20000, declared normalized and off one by 0.200, more than the tolerance of 0.000001, naming K05_COMPOSITION_NOT_NORMALIZED. A normalized control below is a three-state choice. The validation dock reports INVALID with 1 error and 2 warnings, and the conformance findings table lists K05_COMPOSITION_NOT_NORMALIZED as an error against component/ring.
The running total is on screen as it is typed, and the reference validator reports the same code on the exported bytes.
The properties panel showing a measured result being entered: a statistic select set to median, n observed 3, an uncertainty select set to standard deviation with the value 24 in uN, recorded status blank, provenance measured, causal role response, and an observation activity naming a twitch assay. A note says the recorded status is a claim and the Acceptance panel recomputes the verdict. The dock is on the Acceptance tab, showing lot disposition pass, one criterion row for median peak twitch force with requirement median greater than or equal to 150 uN, designed 195 uN, measured 195 uN, n of 3, spread SD 24 uN, no recorded status and a recomputed verdict of pass, plus a named assays table.
A statistic, a sample size and a spread are entered beside the value, and the disposition is derived from the recomputed verdict.
The finished authored package in Design mode. The model tree lists biology with one primary skeletal muscle myoblast population, nine fields including ecm_stiffness as control, stimulation frequency as control, peak twitch force as response, matrix formulation as control and cross sectional area as response, two attachment-loop interfaces, one acceptance criterion AC-001 for median peak twitch force at 1 Hz, and a results branch carrying a realization and one measured result. The viewport draws the axis-aligned box from the named dimensions and notes two regions not drawn because membership is delegated. The Acceptance tab reports lot disposition pass with the criterion met.
A package authored through the interface alone: cells, fields with their causal roles, two interfaces, one acceptance criterion, a realization and a measured result.

Validation

The same reference implementation, while designing.

The workbench posts the package bytes to a loopback bridge. The bridge hands them to the reference validator and transports the structured report back. It reimplements no rule and decides nothing about severity. It listens on loopback only and refuses a request whose origin is not the local dev server.

The Validation tab carries a status line, valid or invalid with error and warning counts and the validator identity, then two tables. Conformance findings hold the codes from the specification, each with severity, location and message. Design rules hold the design-for-manufacture checks, each with the same columns plus a remedy line and its literature source.

What the dock holds
TabContents
ValidationStatus line, conformance findings, design rules.
StudyEngine identity and binding, the transport, the assembly rule check, and the traces with their provenance stated above them.
AcceptanceLot disposition, one row per criterion with designed, simulated, measured, n, spread, recorded and recomputed columns, and the named assays.
Causal projectionThe interventional projection of the build. The workbench projection is compared against the reference in the smoke tests.
ManifestThe manifest records and their digests.
SourceThe document as written.

The assembly has its own rule check in Play mode, reported in errors and warnings beside the conformance findings: ERC09_FLOATING_PART for a part connected to nothing, ERC11_UNRECTIFIED_DRIVE for a drive with no rectification, and ERC13_UNSTATED_PARAMETER, an error, for a physical parameter left unstated.

The mechanism palette

Six part types, their parameters and their ports.

A part is a named type, a set of dimensioned parameters and an ordered feature list that builds the mesh from those parameters. The mesh is derived and is rebuilt when a parameter changes. Every length is a quantity string with an explicit unit. A parameter marked physical decides what the part does rather than what it looks like.

Palette parts
Part Type Parameters Physical Ports Summary
Anchor post anchor width, depth, height none face (mechanical), base (ground) A fixed post. Ground for the rest of the assembly: whatever is bound to it does not move.
Lever lever length, width, thickness, pivot_fraction pivot_fraction in, out (mechanical), pivot (ground) A rigid beam on a pivot. Trades the short travel of a tissue for a longer stroke, or the reverse.
Pinwheel pinwheel radius, blades, hub_radius, thickness radius, blades rim (mechanical), axle (ground) A hub with radial blades on a free axle. Spins when something drives its rim in one direction.
Flexure flexure length, width, thickness, material, beams, folds thickness, material a, b (mechanical) A thin beam that bends instead of hinging. No bearing, no backlash; its stiffness is a design parameter.
Spring spring stiffness, free_length, width, coils, wire stiffness a, b (mechanical) A compliant return element. A muscle can only pull, so something has to pull it back.
One-way clutch clutch direction, radius, teeth, thickness, preload direction input, output (mechanical), frame (ground) A ratchet. Passes motion one way and slips the other.
Parameter kinds and how they are read
KindRead asExample
lengtha quantity string with a length unit"3 mm"
counta whole number, no unit6
fractiona dimensionless fraction0.3
quantitya quantity string in the unit the parameter is stated in; another unit is refused, not converted"2 N/m"
enumone of a closed set, rendered as a selectadvance_ccw
The workbench in Play mode with six parts placed and no nets. The assembly pane on the left lists the palette buttons for component/strip, anchor post, lever, spring, flexure, one-way clutch and pinwheel, then the six placed parts with their stated parameters, and an assembly rule check of six ERC09_FLOATING_PART warnings, one per part, each noting the part will be drawn and take no part in the study. The viewport shows an anchor block, a six-bladed pinwheel, a toothed ratchet wheel, a lever and a zig-zag spring, each labelled. The properties panel on the right shows the pinwheel: its summary, id, type and pose, placement fields for x, y, z and rotation about z, and a parameters table with radius 4 mm and blades 6 both starred, hub_radius 0.8 mm and thickness 0.3 mm, each row listing its acceptable units and a note describing what the parameter does.
Every parameter is an editable field or a select for a closed set, states its acceptable units and its domain on screen, and is starred when it is physical.

What the engine computes

Channels, and the envelope every parameter wears.

A tissue element is a Hill-type contractile line element between two attachment points. It pulls and never pushes, and passive tension appears only above slack length. Internally the engine is strict SI. Every plottable quantity is a channel with a stable id, a unit, a quantity kind and provenance simulated.

Channel ids the reference scene produces
Channel Unit Meaning
tissue/<id>/force, /active_force, /passive_forceNTension along the line of action and its two components.
tissue/<id>/length, /strain, /velocitym, 1, m/sKinematics of the contractile line element.
tissue/<id>/activation1Zero to one, after twitch summation.
tissue/<id>/capacity1One is fresh. Falls with fatigue.
tissue/<id>/power, /workW, JMechanical output.
body/<id>/x, /y, /theta, /omegam, m, rad, rad/sRigid body pose and rate. Always recorded, so the scrub bar can redraw.
rotor/<id>/rpm, /drag_torque1/min, N*mSigned rotor speed and the drag opposing it.
clutch/<id>/count, /engaged, /direction, /driven_angle1, 1, 1, radTeeth advanced, engagement, the sign it rectified, and net rotation of the body it carries.
spring|flexure/<id>/stiffness, /forceN/m, NThe rate the run used and the tension in the element.
diaphragm/<id>/deflection_ratio, /stiffness1, N/mDeflection over thickness, and stiffness derived from the sheet.
neural/<id>/firing_rate, /burst_rate, /network_burst_rate, /active_fractionHz, 1/min, 1/min, 1Spike statistics from a neural unit.
solver/residual1Constraint residual behind the status line.

Each tissue parameter carries a provenance envelope: value, unit, provenance class, and a source where the class requires one. A parameter interpolated between two published anchors is tagged inferred and names both anchors. A parameter with no anchor is assumed and says so in the study. Nothing is silently defaulted.

A session

The first-run path, as the test drives it.

The first-run test starts with an empty application and ends with a package reopened from disk: 53 interactions and 2073 ms of machine time. The elapsed time is a machine driving the interface, so it times the application and not a person. What transfers to a person is the interaction count and that no step needed documentation.

Landmarks on the first-run path
Machine time Interactions Landmark
110 ms1package created
287 ms7cells stated
446 ms17acceptance criterion stated
485 ms18play mode
519 ms19strip placed
585 ms21anchors placed
654 ms25ends connected
722 ms29stimulation set
821 ms30first run
1122 ms36drive train placed
1409 ms50drive train connected
1790 ms51pinwheel turning
1967 ms52study written
2073 ms53reopened from the file

The first-run summary reports, as simulated, a peak twitch force of 148.0 uN and a rotor turned 62.2 degrees at up to 1.38 rpm.

Play mode at the end of the first-run path, with a banner reading all 10 first-run steps done. The assembly pane lists nine parts, four anchor posts, a lever, a flexure, a one-way clutch and a six-bladed pinwheel alongside the component strip, and seven nets. The viewport draws the assembly: the red strip runs from an anchor to the lever input, the lever drives a toothed clutch wheel, and the pinwheel sits below, with the viewport line reading assembly 9 parts, 7 nets, sample 5001 of 5001. The properties panel shows a net from clutch:output to pinwheel:rim of kind rigid_attachment. The Study tab names the engine and the API document it is bound to, shows a filled transport bar at t equals 10 s of 10 s and a write study into package button, reports an assembly rule check of 0 errors and 1 warning for a floating anchor, states that everything below is provenance simulated and not a measurement, notes that the pinwheel axle is held by the stage as a ground port, notes that the document states stimulation amplitude as a field strength with no mapping to the engine excitation so the run assumed a supramaximal stimulus, and plots a force trace peaking at 147.962 microNewtons over ten seconds of repeated twitches.
The strip pulls a lever, the lever drives a one-way clutch, the clutch spins a pinwheel against fluid drag. The Study tab states the transport, the rule check and the assumptions the run made.

The reference run

Every number below is simulated.

As the run summary reports it, all provenance simulated
QuantityValue
simulated10 s at 2 Hz stimulation, 5001 samples
wall clock0.33 s in the browser
peak tissue force147.3 uN
peak active force147.3 uN
peak activation0.205
peak shortening1.5 %
capacity at end1.000 (1 = fresh)
work delivered0.8 nJ
peak rotor speed1.36 rpm
rotor rotation55.2 degrees
clutchsmooth sprag, no teeth (a tooth count quantises the stroke)
ledger25 parameters, 7 designed, 11 inferred, 6 assumed, 1 measured

These are outputs of a model, not measurements of a tissue. The engine hard-codes provenance simulated on everything it emits, writes no measured results and no yield, and a comparison against a designed requirement returns consistent, inconsistent or inconclusive rather than pass or fail.

Play mode with a completed run, the banner reading all 8 first-run steps done. The assembly pane lists eight parts, three anchors named hub, post and base, a lever, the component strip, a flexure, a clutch and a pinwheel, and seven nets. The viewport draws the assembly with the orange strip from the post down to the lever, the pinwheel and toothed clutch at the centre, and a lever arm to the right, reading assembly 8 parts, 7 nets, sample 5001 of 5001. The properties panel shows the selected component strip with its pose, its two attachment-loop ports each connected and offering disconnect, and a stimulation block explaining that these are controls on the article rather than settings on the simulator, with frequency 2 Hz and an imposed by field. The Study tab reports an assembly rule check of 0 errors and 0 warnings, no assembly problems found, that the traces are provenance simulated and not a measurement, and plots a force trace peaking at 147.312 microNewtons with an active force trace beginning below it.
The assembly rule check is clean, and stimulation is written onto the article as a control with the means that imposes it, not held as a simulator setting.

The round trip

A study written into the package and reopened.

Writing the study adds simulation models, runs and results to the package, and carries the traces as a delegated CSV named by the run that produced it, manifested with its digest. Reopening reads the trace back out. The reopened session has no live run: the sample count, the peak force and the final rotation match the live run, and the viewport states the file it is drawing from.

A reopened package named reopened.wwd, in Play mode, at step 8 of 8. The properties panel shows package facts: specification WWD 0.1, root component component/strip, design revision 0.1.0, a urn:uuid package id, producer wwd-workbench selftest, one component, zero acceptance criteria, as-built no with the note that the results document carries a prediction and not a lot, no extensions required, and the mechanism extension listed under extensions used. The viewport draws the same eight-part, seven-net assembly and reads sample 3101 of 5001 from study/run-wwd-sim-0001-traces.csv. The Study tab says the traces were read back out of this package as a delegated CSV of 5001 samples of 23 channels, named by the run that produced it and verified by its digest, that no engine is involved because the motion is in the file, and plots the force trace with a playhead at t equals 6.2 s of 10 s from the package.
The scrub bar works on a package that was just opened, because the motion is in the file rather than in an engine.

What is proven

The browser suites and what each drives.

tests/
SuiteWhat it drives and asserts
ui-smoke.mjsOpens each shipped example, reads the validator status, counts model-tree rows, reads the disposition and the acceptance table, compares the workbench causal projection against the reference, verifies every manifest digest, and re-exports each package to check the design and results documents round-trip with no archive entry lost.
author-smoke.mjsAuthors a package through the UI alone. Asserts the response refusal and the bind-it-as-a-response button, that a registered term shows no causal-role select, the running composition total, K05_COMPOSITION_NOT_NORMALIZED agreement with the reference validator, uncertainty and sampling entry, and that the finished package has zero errors and reopens unchanged.
palette-smoke.mjsPlaces one of every part type, checks each parameter is surfaced with an editable field or a select for a closed set, that it states its domain and its unit on screen, that physical parameters are starred, and that clearing one reports ERC13_UNSTATED_PARAMETER.
play-smoke.mjsBuilds a six-part assembly with five nets through the UI, checks the assembly rule check, ERC11_UNRECTIFIED_DRIVE on an unrectified drive, that stimulation is written onto the article, that the assembly round-trips, and that the mechanism extension is declared and prefix-bound without being required of a reader.
run-smoke.mjsCompiles the assembly to a scene, runs it, checks convergence, force, activation, shortening, lever rotation and rotor speed, that every simulation provenance value is simulated, that reversing the clutch reverses the rotor, that the study writes one model and one run with a digested trace file, and that the reopened package reproduces the run with no engine.
firstrun.mjsDrives the whole first-run path from an empty application to a reopened package, timing each landmark and counting interactions.

Each suite drives the real interface in a browser, fails on a console error, and writes the screenshots on this page as it goes. Both summaries on this page end with the line all checks passed.

What the application does not do

The boundary of the workbench.

Outside the application
Not doneRule
Implement validation rulesThe application does not reimplement, wrap or interpret any conformance rule. The package bytes are posted to a loopback bridge that hands them to the reference validator and transports the structured report back. The bridge listens on loopback only and refuses a request whose origin is not the local dev server.
Own the registry meaningThe workbench reads a one-way synced copy of the Core property registry, stamped with the source path and a SHA-256 per file. The stamp is on screen in the title bar and in the add-a-property panel.
Produce measured numbersEvery value leaving the engine is provenance simulated. There is no parameter, option or override that produces another value, and simulation writes no measured results and no yield.
Return pass or fail from a simulationA comparison against a designed requirement is an assessment returning consistent, inconsistent or inconclusive. A criterion that does not permit simulation gets no assessment at all.
Report a run that did not convergeCompletion and convergence are separate facts. A run that finished without reaching tolerance emits no results. A blow-up stops integration and the run is reported as not complete.
Run an engine on a reopened packageThe motion of a reopened package is read from the delegated trace CSV named by the run and verified by its digest. The scrub bar works on a package with no live run.
Draw delegated region membershipThe Design viewport draws an axis-aligned box from the named dimensions and states the regions it did not draw because membership is delegated.
Carry cartridge geometryEvery palette shape is a textbook primitive: a rectangular post, a beam with a pivot, a hub with radial blades, a ratchet wheel.

Nothing here is published software. The application, its packages and its screenshots are local.

Questions

What is the WWD Workbench?

A local application that opens a .wwd package, authors it, validates it, simulates it and exports it again. It has two modes. Design mode edits the article: the model tree, the named dimensions, the biology, the property fields, the interfaces and the acceptance criteria. Play mode places the article among mechanism parts, connects ports into nets, runs the simulation engine, and writes the study into the package. The panes are a model tree or assembly list on the left, a 3D viewport in the centre, a properties table on the right, and a validation dock along the bottom with tabs for Validation, Study, Acceptance, Causal projection, Manifest and Source.

What happens when a response is bound as a control?

The workbench refuses. A property added from the Core registry carries the registry causal role, and the properties panel displays that role rather than offering it as a select. Selecting a registered response states the consequence before anything is written, names the diagnostics a file claiming an imposed response would earn, A8_RESPONSE_IMPOSED and V03_CAUSAL_CLASS_MISMATCH, and offers a single button that binds it as a response. The author smoke test asserts all three behaviours: the stated consequence, the button naming what it will bind, and the absence of a causal-role select on a registered term.

Which validator runs while designing?

The reference validator. The workbench posts the package bytes to a loopback bridge which calls the reference implementation and returns the structured report. The bridge reimplements no rule and decides nothing. The validation dock reports the status line, valid or invalid with error and warning counts, and the validator identity. Findings arrive in two tables: conformance findings, with severity, code, location and message, and design rules, the design-for-manufacture checks, in a second table under the same tab.

What does the simulation engine compute?

A tissue element is a Hill-type contractile line element between two attachment points. It pulls and never pushes, and passive tension appears only above slack length. The engine integrates that tissue against rigid bodies, joints, flexures, springs, one-way clutches, rotors and diaphragms, and exposes every plottable quantity as a channel with a stable id, a unit, a quantity kind and provenance simulated. Channels cover force and its active and passive components, length, strain, velocity, activation, capacity, power, work, body pose and rate, rotor rpm and drag torque, clutch count, engagement, direction and driven angle, spring and flexure stiffness and force, diaphragm deflection ratio and stiffness, neural firing, burst and network burst rates, and the constraint residual.

Where do the tissue parameters come from?

Each parameter wears a provenance envelope carrying its value, unit, provenance class and, where the class requires it, a source. Published anchor points sit in the engine data file with their citation, the quantity each fixes and the conditions they were taken under. A design between two anchors gets an interpolated parameter tagged inferred, naming both anchors and the position between them. A parameter with no anchor is assumed and says so in the study. The run summary reports the ledger for the reference run as 25 parameters, 7 designed, 11 inferred, 6 assumed and 1 measured.

What does a session look like?

The first-run test drives the application from an empty state to a reopened package in 53 interactions and 2073 ms of machine time. Landmarks: package created at 1 interaction, cells stated at 7, acceptance criterion stated at 17, play mode at 18, strip placed at 19, anchors placed at 21, ends connected at 25, stimulation set at 29, first run at 30, drive train placed at 36, drive train connected at 50, pinwheel turning at 51, study written at 52, reopened from the file at 53. The elapsed time is a machine driving the UI and times the application rather than a person. What transfers is the interaction count and that no step needed documentation.

What are the simulated numbers for the reference run?

The run summary reports, all as simulated and none as measured: 10 s at 2 Hz stimulation, 5001 samples, wall clock 0.33 s in the browser, peak tissue force 147.3 uN, peak active force 147.3 uN, peak activation 0.205, peak shortening 1.5 percent, capacity at end 1.000 where 1 is fresh, work delivered 0.8 nJ, peak rotor speed 1.36 rpm and rotor rotation 55.2 degrees, with a smooth sprag clutch and no teeth. The first-run summary for its own longer path reports peak twitch force 148.0 uN and a rotor turned 62.2 degrees at up to 1.38 rpm. Every value is provenance simulated and is not a measurement of anything.

What is in the mechanism palette?

Six part types: anchor post, lever, pinwheel, flexure, spring and one-way clutch. Each is a named type with dimensioned parameters and an ordered feature list that builds the mesh, so the mesh is derived and is rebuilt when a parameter changes. Every length is a quantity string with an explicit unit and counts are plain integers. Seven parameters across the six types are marked physical, meaning the part does not describe a physical thing without them: the lever pivot fraction, the pinwheel radius and blade count, the flexure thickness and material, the spring stiffness and the clutch direction. An unstated physical parameter is reported as ERC13_UNSTATED_PARAMETER, an error rather than a quiet default.

How does the round trip work?

A finished run is written into the package as simulation models, runs and results, with the traces carried as a delegated CSV named by the run and recorded in the manifest with its digest. Reopening the package reads the trace back: the reopened session has no live run, the sample count and the recorded rotation match the live run, the channel list comes back with units, and the viewport states that it is drawing from the trace file. The properties panel reports as-built as no, because a results document carrying a prediction is not a lot.

What does the application not do?

It does not implement a conformance rule, does not carry its own copy of the registry meaning, does not produce a value marked measured, does not return pass or fail from a simulation, does not report results from a run that did not converge, does not run an engine on a reopened package, does not draw region membership that is delegated, and carries no cartridge geometry in any part, default or screenshot.

Continue

Related pages.