Skip to main content

HulyaPulse and Zeqond

HulyaPulse — the 1.287 Hz system clock​

The HulyaPulse is the framework's 1.287 Hz system clock. Every protocol, every operator, every CKO is phase-locked to it.

The Zeqond is definitional — like the SI second, it is fixed by decree, not derived:

1 Zeqond = τ = 777,000,777 ns   (exact, by definition)
f = 1/τ ≈ 1.287 Hz              (f·τ = 1 exactly in ℚ)

(The earlier published derivation f = c / λ_φ from a field radius has been withdrawn by erratum — see CONSTANTS-CHARTER.md. The honest statement is the one above: τ is the framework's chosen time unit, and everything else is exact arithmetic on it.)

Zeqond — the framework's native time unit​

The Zeqond is the period of the HulyaPulse: T_Z = τ = 0.777 s (display; 777,000,777 ns exactly). This is the page's one definitional anchor — everywhere else, durations are stated in Zeqonds and millizeqonds (1 mz = τ/1000).

Within one Zeqond:

  • Every operator evaluates exactly once.
  • Every composition is bounded by KO42.
  • Every CKO is signed and verifiable.

Across Zeqonds:

  • State is carried forward through the master equation's wave term.
  • Phase evolves deterministically: phi_current = ((t_Unix mod 0.777) / 0.777) × 2 pi.

Why 0.777 and not 1.0​

Fixing the tick at τ instead of one SI second has two effects:

  1. Phase math becomes exact. Multiples of τ produce phase values that live on a rational lattice (f·τ = 1 exactly). Common operations (averaging, quadrature, spectral decomposition) compose without drift.
  2. Unix time remains usable. We don't replace Unix time — we bridge it. ZTB1 is a lossless conversion. Any Unix timestamp can be mapped to a Zeqond count and back.

Practically, an agent running on the framework announces its phase every few messages or after any math step:

[Zeq tick] Zeqond 2292305743 — phase 0.412

This is the telemetry the Zeq skill emits by convention. It is a deterministic unit conversion of Unix time — computed, not received; there is no synchronization event.

Using it from the SDK​

You rarely need to touch the clock directly — the SDK computes it for you. When you do:

import { zeqond } from "@zeq/sdk";

zeqond.now();           // current Zeqond count
zeqond.phase();         // current phase in [0, 1)
zeqond.toUnix(z);       // convert Zeqond count to Unix seconds
zeqond.fromUnix(t);     // convert Unix seconds to Zeqond count

Every SDK response includes a zeqond_at field recording the exact Zeqond when the computation was executed on the hosted API. That value is part of the CKO signature.

Hosted clock service​

The paid hosted API runs the authoritative HulyaPulse at our edge. Clients can self-host a Zeqond service (it's a single loop — see Operate → Self-hosting), but hosted customers get:

  • Signed Zeqond attestations. A signed tuple (zeqond_count, t_unix, phi, sig) you can include in downstream CKOs.
  • Drift measurement. Our edge measures drift against atomic reference. Self-hosted instances should cross-check against this service periodically.
  • Network-agnostic phase. Two clients in different regions compute the same phase for the same Zeqond.

If you self-host for offline work, that's fine — the framework runs standalone. For multi-party attestation, use the hosted service.