Skip to main content

HulyaPulse and Zeqond

HulyaPulse — 1.287 Hz​

The HulyaPulse is the framework's master clock. It oscillates at exactly 1.287 Hz. Every protocol, every operator, every CKO is phase-locked to it.

The derivation follows from the field's characteristic radius r_phi and the speed of light:

lambda_phi = 2 pi × r_phi
f = c / lambda_phi  ≈  1.287 Hz

The number is not arbitrary. It falls out of the geometry of the Zeq field the same way a guitar string's fundamental frequency falls out of its length and tension.

Zeqond — 0.777 s​

The Zeqond is the period of the HulyaPulse: T_Z = 1 / 1.287 = 0.777 seconds (to three significant figures). It's the computational second of Zeq.

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 computational second at 0.777 s instead of 1.0 s has two effects:

  1. Phase math becomes exact. Multiples of 0.777 s produce phase values that live on a rational lattice. 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 Daemon] Zeqond ticked — phase ≈ 0.412 — HulyaPulse 1.287 Hz synced — Zeqonds since Unix: 72380014.8

This is the telemetry the Zeq skill emits by convention.

Using it from the SDK​

You rarely need to touch the clock directly — the SDK synchronizes 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.