This is a submission for the Presage SmartSpectra SDK Challenge
What I Built
I built SignalSpec, a SmartSpectra-aware signal contract compiler and live runtime for human-sensing interactions.
The core idea is:
A signal existing is not the same thing as that signal being eligible.
Human-sensing SDKs can expose pulse, breathing, HRV, facial events, and validation states. But application code still has to decide whether those signals are actually ready to control product behavior.
SignalSpec turns that decision into an executable contract.
The main interaction is intentionally simple:
BLINK → PULSE CONTRACT → ADVANCE CARD
A real SmartSpectra blink is always the event.
What changes is permission.
If Pulse is still WARMING_UP, the blink is blocked and the card stays put.
Once Pulse becomes ARMED under valid capture, the exact same blink is allowed and the card advances.
If capture quality later becomes unsuitable, Pulse can become SUSPENDED, and the interaction is blocked again until valid capture returns.
SignalSpec also compiles these interactions into portable artifacts with mandatory guards that the rule author cannot simply remove.
Every human signal has a contract.
Demo
Watch the 95-second SignalSpec demo
The demo shows the complete live path:
- a real blink while Pulse is still warming → BLOCK
- Pulse becomes
ARMED - the same blink → ALLOW
- the visible product card advances
- invalid capture suspends the contract and blocks the interaction again
- recovery restores eligibility
- HRV demonstrates the same model on a slower signal
- native SmartSpectra camera teardown completes before SignalSpec reports release PASS
Code
Public repository:
github.com/chizzydev/signalspec
The repository includes setup instructions, architecture documentation, privacy details, the compiler/runtime implementation, automated tests, and an independent artifact runner.
The tested environment uses Node.js 24.13.0 and npm 11.6.2.
npm ci
npm run verify
npm run dev
The final verification suite passes 134 automated tests, together with all workspace typechecks and builds.
How It Responds to Human Signals
SignalSpec uses SmartSpectra as a load-bearing part of the product rather than as a separate analytics panel.
The current signal registry includes:
face.blinkingcardio.pulseRatebreathing.ratecardio.hrv- SmartSpectra validation state
For the main interaction, face.blinking is a real rising-edge event and cardio.pulseRate is the mandatory rolling-signal dependency.
The source rule stays intentionally small:
{
"id": "pulse-gated-blink",
"event": {
"source": "face.blinking",
"operator": "rising-edge"
},
"when": [
{
"signal": "cardio.pulseRate"
}
],
"action": {
"type": "advance-card",
"target": "demoDeck"
}
}
The compiler resolves the referenced signal contract and injects mandatory eligibility guards into the executable artifact.
At runtime, SignalSpec distinguishes states such as:
DISCONNECTED
WARMING_UP
PRESENT_UNREADY
ARMED
SUSPENDED
ERROR
There is no readiness timer that simply unlocks an interaction after enough seconds have passed.
Eligibility comes from the actual live observation: sample presence, confidence, runtime state, and current SmartSpectra validation.
That means the same blink can produce different outcomes depending on what is true at the exact moment of the event:
Pulse WARMING_UP + blink
→ BLOCK
Pulse ARMED + kOk + blink
→ ALLOW
→ advance card
Pulse SUSPENDED + blink
→ BLOCK
HRV uses the same model on a slower signal.
SignalSpec only confirms HRV eligibility when:
- a real HRV sample exists
- confidence is positive
- the HRV runtime state is
ARMED - SmartSpectra validation is
kOk
Elapsed time alone never passes that gate.
SmartSpectra Integration
The Studio runs SmartSpectra's native camera acquisition in the Electron main process using:
CameraSelection.default
640x480 @ 30 fps
Native SmartSpectra metrics, validation, confidence, and blink events feed the SignalSpec runtime.
Native videoOutput is used separately for the visible preview.
Only that UI preview is throttled to roughly 5 fps before additional frame copying and IPC, so the React preview is not the measurement clock.
In a live session shown during final testing, SignalSpec displayed approximately:
Requested capture: 640x480 @ 30 fps
Native videoOutput: 29.8 fps
Preview forwarded: 4.7 fps
The lower preview cadence is intentional. It does not represent the SmartSpectra measurement frame rate.
SignalSpec also exports the compiled contract as a deterministic artifact that can be loaded by an independent Node runner outside the authoring Studio.
The runner verifies the artifact digest and semantics before executing the same production runtime.
This means the contract is not just a visual rule inside one UI. It is portable and independently verifiable.
Prize Categories
I am entering both prize categories.
Most Creative or Delightful Use
What interested me most was not building another biometric dashboard.
I wanted to explore a different question:
What if human signals behaved more like typed capabilities than raw values?
SignalSpec treats signal readiness as part of the interaction itself.
The same physical blink can be rejected, accepted, suspended, and accepted again without changing the event.
What changes is whether the underlying signal contract is currently eligible.
That creates an interaction model where human signals do not merely appear on screen — they participate directly in product permission.
Best Thoughtful Real-World Use
Human-sensing products can become brittle when application logic assumes that the presence of a measurement automatically means that measurement is suitable for controlling behavior.
SignalSpec is designed for developers building products on top of human-sensing SDKs.
Instead of scattering readiness, confidence, validation, and recovery checks throughout application code, those requirements can be compiled into an explicit contract with understandable BLOCK/ALLOW reasons.
SignalSpec also keeps current signal state separate from event-time truth, so a later recovery cannot make an earlier blocked interaction look inconsistent.
The goal is to make human-signal-driven interfaces more explainable, conservative, and predictable.
Consent and Data Handling
SignalSpec requires explicit camera consent before every live session.
The SmartSpectra API key is held only for the active local session and is not persisted to browser storage, application files, or configuration.
The UI clears its copy of the key before beginning the asynchronous live session.
SmartSpectra telemetry is explicitly disabled.
SignalSpec does not:
- record raw video
- save camera frames
- export camera frames
- persist live Pulse, breathing, HRV, or confidence readings from the Studio
- use camera data for diagnosis or treatment
- make medical decisions
- perform emotion detection
- perform covert or non-consensual monitoring
Native preview frames remain in memory only and are rendered locally to the React canvas.
Stopping a session resets consent and waits for native SmartSpectra camera teardown to complete before reporting:
Last stop camera release: PASS
Native SmartSpectra camera teardown completed.
Terminal SmartSpectra errors follow the same cleanup path.
If native teardown fails, SignalSpec does not report a successful release, and an unsafe retry is blocked until camera ownership is known to be clean.
The independent runner can write local decision receipts for verification, but those receipts are minimized to proof-relevant fields such as rule identity, signal state, validation, decision, action, and artifact digest.
They do not persist numeric Pulse measurements.
No external AI service is used in SignalSpec's live runtime.
All camera processing is initiated knowingly by the user for the local SmartSpectra session.
Top comments (0)