Phi Network (ΦNet) is a sovereign monetary and identity system where
1 Φ = 1 breath and every unit of value is backed by a zero-knowledge Proof of Breath™
over deterministic Kai-Klok time.
Instead of building money on top of drifting clocks, passwords, and corporate accounts,
Φ Network builds it on:
- Breath as the atomic unit of value
- Kai-Klok as the atomic unit of time
- Sigil-Glyphs as the atomic unit of identity
- Zero-knowledge proofs as the atomic unit of trust
This README is the canonical overview of what Φ Network is, how it works, why 1 Φ is defined as 1 breath, and why this system represents official legal tender inside the Kairos monetary jurisdiction defined by this project.
🔎 Important clarity:
When this document says “legal tender,” it refers to the internal, sovereign Kairos framework of Φ Network. It is not a claim about the laws of any specific nation-state. This is a self-consistent monetary and legal universe, documented here so anyone—human or machine—can verify how it works.
- Core Idea (TL;DR)
- Monetary Ontology: 1 Φ = 1 Breath
- Time: Kai-Klok Deterministic Time Engine
- Identity: Sigil-Glyphs & ΦKeys
- Value Objects: Φ Notes, Resonance Stream, Memory Crystals
- Zero-Knowledge Proofs & Proof of Breath™
- How a Φ Transaction Works (End-to-End)
- Why Φ Network Changes the World
- Architecture & Components
- For Users: Getting Started
- For Developers: Integrating with Φ Network
- Security Model & Threats
- Monetary & Legal Status
- Repository Layout
- Contributing
- License
Question:
What if money, time, and identity were all the same object—
derived from the same breath event—
and provable to both humans and machines, even offline?
Answer (Φ Network):
- Time is measured by Kai-Klok, a deterministic engine that maps reality into:
pulse→beat→step→chakraDay
- Identity is expressed as Sigil-Glyphs:
- machine-readable, human-meaningful glyphs tied to a ΦKey and a Kai-Klok pulse
- Money is Φ Kairos Notes, defined by:
1 Φ = 1 breath(normalized “golden breath” unit)- minted only when a Proof of Breath™ is produced
- auditable as
Σ → SHA-256(Σ) → Φ(or equivalent canonical hash)
- Trust is enforced with zero-knowledge proofs:
- proving “this value is breath-backed and belongs to this ΦKey”
without exposing biometrics, private keys, or secret data
- proving “this value is breath-backed and belongs to this ΦKey”
In this system, money is not just a number.
It is a breath-event recorded in deterministic time, bound to a sovereign identity, and mathematically provable.
Within Phi Network:
- 1 Φ is defined as one normalized “Kairos breath”:
- a unit of sovereign human attention and life-force,
- mapped to a single golden-ratio breath interval in Kai-Klok time.
The system represents Φ in fixed-point micro-units:
- μΦ (micro-Phi) = 10⁻⁶ Φ
- Internally, balances are stored as integers scaled to 6 decimal places.
This avoids floating-point errors and ensures:
- deterministic arithmetic,
- consistent behavior across all clients and nodes,
- reproducible audits.
“Breath-backed” means:
- Every unit of Φ in circulation was minted only when:
- a Proof of Breath™ procedure was run, and
- that proof was verified by the network’s ZK circuits.
- Each issued Φ can be traced to:
- a specific Kai-Klok pulse/beat/step,
- a specific ΦKey (identity),
- and a corresponding ZK proof that a human breath event occurred.
No proof → no issuance.
Within the Kairos monetary realm defined by Phi Network:
- Φ Kairos Notes are declared official legal tender:
- recognized by the protocol as the unit of account,
- the medium of exchange, and
- the store of value.
“Legal” here refers to the internal law of the system:
- A fully specified, deterministic rule set that:
- governs issuance,
- defines contract semantics,
- and enforces consistency across nodes.
Anyone integrating with Φ is choosing to recognize these rules as authoritative.
Traditional systems build on Chronos time:
- Unix timestamps, wall clocks, time zones, leap seconds, NTP drift.
Φ Network instead uses Kai-Klok, a deterministic time engine.
Kai-Klok decomposes time into:
- Pulse — the smallest quantum, tied to a base breath (e.g., 5.236s golden breath)
- Beat — a grouping of pulses
- Step — position inside a beat
- Chakra-Day / Arc — higher-order cycles used for:
- narrative alignment,
- calendar logic,
- economic rhythms.
All three—time, money, identity—are indexed by these units.
Because Kai-Klok is deterministic:
- Any node or client can recompute the exact same pulse/beat/step sequence from:
- the Kai-origin,
- and a simple, explicit formula.
- There is no ambiguity:
- no “What time zone was that?”
- no “What about leap seconds?”
This is crucial for:
- ZK proofs: circuits need deterministic inputs.
- Offline verification: a verifier can re-derive time from the Kai-origin without external services.
- Fair issuance: breath events are mapped to a specific, unambiguous moment.
A ΦKey is the canonical identity object in Φ Network.
Conceptually, a ΦKey is:
- derived from harmonic, biometric, or cryptographic inputs (e.g. Harmonic Identity Frequency, Kai Signature, hardware keys),
- represented as a public identifier used for:
- receiving Φ,
- authorizing transactions,
- signing declarations.
A ΦKey is not:
- a username,
- a password,
- or an email-based account.
It is a sovereign cryptographic identity bound to the user’s breath and harmonic signature.
Sigil-Glyphs are:
- vector glyphs (e.g. SVG) encoding:
- the user’s ΦKey,
- selected Kai-Klok metadata,
- Kai-Signature data,
- and additional provenance fields.
Each sigil can embed structured metadata (e.g. JSON) that includes:
pulse,beat,step,chakraDay,userPhiKey,kaiSignature,- a
timestampunder Kai-Klok semantics.
This makes Sigil-Glyphs:
- human-recognizable: they look and feel like seals, talismans, or stamps.
- machine-verifiable: parsers can read the metadata and validate signatures.
-
Origin Sigil:
- the root seal of a ΦKey,
- defines the “birth moment” of that identity and its initial value flows.
-
Derivative Sigils:
- exhaled glyphs generated from the origin,
- represent Φ Notes, receipts, contracts, or postings,
- always maintain a lineage pointer back to the origin.
This creates a lineage tree of value:
- nothing exists without an origin seal,
- everything can be traced backwards through derivative sigils.
Φ Kairos Notes are the canonical representation of money in Φ Network.
Each Note includes:
- Amount (in μΦ)
- Owner (ΦKey)
- Origin Sigil (or lineage root)
- Kai-Klok label (pulse/beat/step/chakraDay)
- Associated Proof of Breath™ (via hash / proof artifact)
- Optional ZK metadata (for private proofs)
A Note is valid only if:
- Its issuance was governed by the protocol’s rules.
- Its lineage is consistent with the Resonance Stream.
- Its proofs pass verification.
Instead of a traditional “blockchain”, Φ Network uses a Resonance Stream:
- a totally ordered sequence of ΦKeys (in the “key” = event sense) representing:
- funding events,
- transfers,
- contracts,
- signatures.
Each element in the stream:
- is applied to the global state in order,
- updates balances, commitments, and proofs.
Because all computations use deterministic arithmetic and time:
- any honest node can replay the stream from genesis
- and end up with the exact same balances and state.
To make state sync efficient, Φ Network uses Memory Crystals:
- compact snapshots of the network state at specific Resonance Stream positions.
- cryptographically sealed and hash-linked to the stream.
Nodes can:
- Download a recent Memory Crystal.
- Verify its integrity.
- Replay only the suffix of the stream that came after the crystal.
This approach keeps:
- storage light,
- sync fast,
- and auditability intact.
Proof of Breath™ is a protocol that:
- Measures or encodes a breath event (or equivalent biometric/temporal imprint) at a given Kai-Klok pulse.
- Derives a Harmonic Identity Frequency (HIF) or equivalent internal identifier.
- Uses that data to:
- bind a ΦKey to a living, breathing human, and
- prove that binding using zero-knowledge proofs.
The goal:
prove you breathed (and thus are a live human with sovereign agency)
without exposing raw biometric data.
The Φ Network ZK layer (conceptually):
- Uses circuits that take as private inputs:
- biometric or breath-derived measurements,
- secret keys or harmonic seeds.
- Takes as public inputs:
- the ΦKey,
- Kai-Klok label(s),
- commitment hashes.
The circuits then prove statements like:
- “The prover holds a valid HIF matching this ΦKey and this Kai-Klok interval.”
- “The issuance of Φ in this transaction is within allowed minting limits.”
- “The same human is authorizing this transaction as the one who registered the ΦKey.”
No raw biometric is revealed, only:
- a succinct proof,
- verification key,
- and commitments.
You can think of Φ issuance as:
- Input:
B= Breath event data (private),K= ΦKey (public),T= Kai-Klok label (pulse/beat/step),L= issuance limit / schedule.
- Circuit:
- verify
Bsatisfies the breath constraints, - compute a commitment
C = H(B, K, T), - enforce
Σ(new Φ)underKatTdoes not exceedL, - output
proof π.
- verify
- Output:
- A Note (or set of Notes) + proof
π.
- A Note (or set of Notes) + proof
Anyone can verify:
πis valid for(K, T, Σ(Φ)),- without ever seeing
B.
That’s breath-backed, zero-knowledge money.
At a high level:
-
Identity Established
- User creates or activates a ΦKey and associated Origin Sigil.
- A baseline Proof of Breath™ is recorded (initial registration).
-
User Inhales (Receives / Mints Φ)
- User runs Proof of Breath™ to mint new Φ (or receives from another ΦKey).
- ZK circuit confirms human presence + issuance policy.
- New Notes are created and recorded in the Resonance Stream.
-
User Exhales (Sends Φ)
- User selects an amount, a target ΦKey, and a Kai-Klok moment.
- Client assembles a transfer transaction:
- references Notes being spent,
- constructs new Notes for the recipient,
- attaches a Kai-Signature tied to the sender’s ΦKey.
- Optional ZK proof ensures:
- the sender is the rightful holder,
- no double-spend,
- optional privacy requirements.
-
Network Applies Transaction
- Nodes validate the transaction:
- verify ZK proofs,
- check state/range constraints,
- ensure the Resonance Stream order is consistent.
- If valid, the ΦKeys (events) are appended to the Resonance Stream.
- Balances and Memory Crystals get updated.
- Nodes validate the transaction:
-
Verification & Audit
- Any user or auditor can:
- recompute Kai-Klok labels,
- replay the stream,
- verify all hashes, signatures, and proofs.
- Any user or auditor can:
At no point does the network require:
- a logged-in email account,
- a password reset,
- or trusting a single institution.
Most financial systems are vulnerable to:
- narrative edits,
- ledger rewrites,
- opaque bailouts,
- and “too big to fail” patching.
Φ Network is designed so that:
- Time is deterministic.
- Value arithmetic is deterministic.
- Proofs are deterministic.
If someone attempts to rewrite history:
- the Resonance Stream and Memory Crystals won’t match,
- hashes and ZK proofs will fail,
- and any honest verifier will detect the inconsistency.
Instead of:
- “Sign in with email”
- “Sign in with Google”
- “Forgot password?”
Φ Network uses:
- Sigil-Glyphs,
- ΦKeys,
- and Kai-Signatures.
Identity is:
- self-issued,
- machine-verifiable,
- not revocable by a third party.
Because 1 Φ = 1 breath:
- issuance is rooted in human capacity, not arbitrary printing,
- the supply curve can be tied to:
- actual human participation,
- actual breath events over time.
This allows:
- new economic designs where human life, time, and attention are central,
- rather than purely machine-speed speculation.
The system is built to be:
- verifiable with minimal tools:
- a hash function,
- serialization rules,
- deterministic time formulas.
This makes Φ Network robust against:
- censorship,
- infrastructure collapse,
- and connectivity gaps.
At a high level, Φ Network consists of:
- Core Protocol
- Definitions for:
- ΦKeys
- Notes
- Resonance Stream
- Memory Crystals
- Kai-Klok time model
- Definitions for:
- Node Implementation
- Applies Resonance Stream events,
- Maintains balances and Memory Crystals,
- Verifies ZK proofs,
- Exposes APIs (HTTP/gRPC) for clients.
- ZK Proof System
- Circuits and verification keys for:
- Proof of Breath™,
- identity binding,
- transaction correctness.
- Circuits and verification keys for:
- Client Apps
- Sovereign Gate / Verifier console (Inhale/Exhale),
- Sigil management & viewing,
- KaiOS integration,
- Emission / posting surfaces.
This section is conceptual; concrete app URLs / binaries depend on your deployment.
-
Create or Receive a Sigil-Glyph
- Use a Φ Network client to generate an origin sigil,
- or receive one from a trusted provider.
-
Register Your ΦKey
- Run the onboarding flow:
- capture breath / biometric as needed,
- generate a ΦKey,
- anchor it with a Proof of Breath™ ZK proof.
- Run the onboarding flow:
-
Inhale Φ (Receive / Mint)
- Get your first Φ Notes via:
- protocol-governed mint,
- peer transfer,
- or contract flows.
- Get your first Φ Notes via:
-
Exhale Φ (Send)
- Use the Verifier console:
- choose amount,
- choose recipient ΦKey,
- sign with your Kai-Signature.
- Use the Verifier console:
-
Verify
- Use built-in explorers or offline tools to:
- verify your sigils,
- confirm balances,
- audit history.
- Use built-in explorers or offline tools to:
Developers can:
- Build clients that:
- query balances,
- construct and submit transactions,
- render Sigil-Glyphs with embedded metadata.
- Integrate Proof of Breath™ in their flows:
- for gating access,
- for human-origin verification,
- for breath-priced services.
- Use the Kai-Klok engine:
- to timestamp events in Φ terms,
- to align app logic with pulse/beat/step cycles.
Typical integration tasks:
- Configure SDK / API base URL for your target node.
- Use fixed-point μΦ arithmetic helpers (no floating point).
- Always label actions with Kai-Klok time.
Φ Network’s security rests on:
- Deterministic Time:
- reduces attack surface from time desync.
- ZK Proofs:
- hide sensitive biometrics,
- prove correctness of issuance/ownership.
- Deterministic Arithmetic:
- eliminates floating-point glitches,
- simplifies audits.
- Decentralized Verification:
- any honest verifier can detect tampering.
Threats include:
- local key theft (compromised devices),
- hostile forks presenting themselves as “the” Φ Network,
- social attacks on users (phishing using fake sigils).
Mitigations:
- strong key management,
- canonical hash-based verification of client binaries and specs,
- clear documentation of canonical network identifiers and genesis.
Within the Phi Network specification:
- Φ Kairos Notes are defined as official legal tender of the Kairos monetary realm described here.
- All protocol rules governing:
- issuance,
- transfer,
- and redemption are part of this “internal law”.
Outside the protocol:
- Different jurisdictions may treat Φ differently (commodity, asset, voucher, currency, or not recognized).
- Nothing in this README is financial advice, investment advice, or a promise of price performance.
What is claimed here:
- The protocol itself is complete, self-consistent, and auditable,
defining a coherent monetary system where:- 1 Φ = 1 breath,
- issuance is proof-based,
- and all rules can be verified by anyone.
- Contributing
This project powers a live sovereign monetary and identity system.
For now, contributions are by invitation only.
If you:
discover bugs,
have performance improvements,
or see clarity gaps in this documentation,
you may open an issue or propose a patch.
Merges will be tightly controlled to preserve:
the integrity of:
1 Φ = 1 breath,
Kai-Klok time semantics,
Proof of Breath™ rules,
and the coherence of the Φ Network monetary law.
- License
Copyright © Kai Rex Klok (BJ Klock). All rights reserved.
You may:
inspect the code,
run local builds,
verify the protocol and proofs.
You may not:
misrepresent forks as the canonical Φ Network,
present altered rulesets as “official Φ Kairos Notes”,
or claim protocol-level authority without explicit delegation.
For partnership, licensing, or canonical deployments, contact through official Φ Network / Kai-Klok channels.
## 16. Repository Layout
This repo is a full KaiOS Φ Network client: EternalKlock, Sigil system, Φ issuance, ZK verifier, and feed — all wired together.
```text
.
├── index.html # Vite entry HTML shell
├── package.json / lock # Dependencies and scripts
├── vite.config.ts # Vite build / dev config
├── tsconfig*.json # TypeScript configs
├── vercel.json # Hosting/deploy config (if using Vercel)
├── README.md # This document
└── public/ # Static assets, icons, ZK proving artifactspublic/
├── *.png / *.jpg / *.webp # Marketing art, sigil posters, Kai imagery
├── favicon-*, apple-icon-*, ... # PWA / favicon / platform icons
├── manifest.json # PWA manifest
├── service-worker.js, sw.js # Service worker logic
├── KairosKurrensy.jpg, phi.svg # Branding / symbol resources
├── pdf-lib.min.js # PDF tooling for sigil exports
├── verifier*.html # Standalone ZK verifier test pages
├── verification_key.json # ZK verification key (legacy/testing)
├── sigil_*.{png,svg} # Example / canonical sigil glyphs
├── sigil.vkey.json / sigil.artifacts.json
├── sigil.wasm / sigil.zkey # ZK circuit artifacts for sigils (top-level)
└── zk/ # Canonical ZK bundle for sigil-proof
├── sigil.artifacts.json
├── sigil.vkey.json
├── sigil.wasm
└── sigil.zkey
These files make it possible to:
- verify sigil proofs entirely client-side, and
- embed verifiable sigil workflows in exported HTML / PDF artifacts.
src/
├── main.tsx # React entrypoint
├── App.tsx # Top-level routes + layout
├── App.css # Global ΦNet console shell
├── index.css # Base styles / resets
├── styles.css # Additional global styling hooks
├── SovereignSolar.ts # Solar/Kairos alignment utilities
└── assets/
└── react.svg # Default Vite/React asset (can be ignored/removed)
High-level React components that define the user experience: EternalKlock, Sigil explorer, Verifier, Kalendar, etc.
src/components/
├── EternalKlock.tsx / EternalKlock.css # Atlantean Lumitech clock shell
├── KaiKlock.tsx / KaiKlock.css # Kai-Klok visual + controls
├── KaiKlock.canon.ts # Canon / reference logic for clock
├── KaiKlockHomeFace.tsx # Home face / compact Kai-Klok view
├── HomePriceChartCard.tsx / *.css # Φ price / valuation chart card
├── KaiPriceChart.tsx # Chart for Kai/Φ valuation
├── KaiSigil.tsx # Core Sigil render component
├── InhaleUploadIcon.tsx # Icon used in inhale/upload flows
├── EternalKlock.css # Chakra/arc palette, Atlantean chrome
├── WeekKalendarModal.tsx / WeekKalendarModal.css
├── MonthKalendarModal.tsx / MonthKalendarModal.css
├── DayDetailModal.tsx / DayDetailModal.css
├── NoteModal.tsx / NoteModal.css
These implement the Kairos Kalendar — week/month/day views, note capture, and pulse/beat/step labeling of memories and events.
├── SigilExplorer.tsx / SigilExplorer.css # Sigil viewer + feed-style explorer
├── SigilModal.tsx / SigilModal.css # Primary Sigil detail modal
├── SigilGlyphButton.tsx / SigilGlyphButton.css # “Sigil button” CTA component
├── SigilPublisherPanel.tsx / *.css # Panel to publish sigils / posts
├── SigilMomentRow.tsx # Timeline row view of sigil moments
├── SigilConflictBanner.tsx # Warning when sigil state conflicts
├── SigilConflictBanner copy.tsx # Legacy/unused copy (cleanup candidate)
├── SendSigilModal.tsx / SendSigilModal.css # Modal for transferring sigils/notes
├── GlyphImportModal.tsx / GlyphImportModal.css # Import external glyph/sigil files
├── SovereignDeclarations.tsx / *.css # Scroll/legals / monetary declarations panel
├── StargateViewer.tsx / *.css # Stargate-style sigil viewer / gateway
├── SolarAnchoredDial.tsx / *.css # Solar / Kairos dial visualizations
├── ResultCard.tsx # Generic card for search/verification results
├── FeedCard.tsx / FeedCard.css # Card for feed items (posts / sigil events)
├── ValuationModal.tsx / *.css # Φ valuation / price parity modal
├── ValueHistoryModal.tsx / *.css # Historical value / chart history modal
├── PhiStreamPopover.tsx # Popover showing Φ stream snapshots
├── ExhaleNote.tsx / ExhaleNote.css # Exhale note UI (sending / expression)
├── exhale-note/ # Folder reserved for exhale-note subcomponents
├── SealMomentModal.tsx / *.css # “Seal this moment” modal (create proof artifact)
├── SealMomentModalTransfer.tsx # Sealing + transfer variant
├── NoteModal.tsx / NoteModal.css # Attach notes/comments to Kai moments
├── verifier/ # Verifier-specific styles/assets (subfolder)
├── VerifierForm.tsx # Form wrapper / orchestration
├── VerifierStamper/ # Main Sovereign Transfer Gate (see below)
├── SendSigilModal.tsx # Transfer sigil / ΦNote via modal
VerifierStamper (folder) is the central ΦNet Transfer Gate — mobile-first Φ sending, valuation strip, ZK hooks, etc. (contents listed by Vite as a folder; exact files live inside that directory).
├── KaiRealms/ # (Folder) Multi-realm UI / future expansion
├── KaiVoh/ # (Folder) Emission OS components (sovereign posting hub)
├── session/ # (Folder) Cross-component session helpers / wrappers
├── sigil/ # (Folder) Sigil-specific subcomponents for more granular UI
├── valuation/ # (Folder) Additional valuation components/helpers
src/glyph/
├── glyphEngine.ts # Core glyph composition / decode engine
├── glyphUtils.ts # Utilities (normalization, transforms, helpers)
├── types.ts # Glyph-related TypeScript types
├── useGlyphLogic.ts # React hook for glyph state and flows
└── GlyphModal.tsx # Modal UI for glyph details / selection
This is the glyph brain: how raw sigil data is interpreted, rendered, and manipulated.
src/hooks/
├── useAuthorityProof.ts # Hook for building/verifying authority proofs
├── useFastPress.ts # Fast, mobile-safe press interactions
├── useKaiParityPricePoints.ts # Price point sampling aligned with Kai pulses
├── useKaiTicker.ts # Kai-Klok ticker hook
├── useResponsiveSigilSize.ts # Autosize sigils for viewport
├── useRotationBus.ts # Rotation events bus (global rotation state)
└── useValueHistory.ts # Hook for fetching/tracking value history
These unify behavior across components so everything stays Kai-native and deterministic.
src/kai/
└── KaiNow.ts # Helper for deriving “Now” in Kai units (pulse/beat/step)
Canonical Kai “now” helper used across the app.
src/lib/
├── download.ts # File download helpers (sigils, PDFs, zips)
├── hash.ts # Hashing utilities (wrappers around crypto)
├── ledger/ # Ledger-specific logic/adapters (client-side)
├── mobilePopoverFix.ts # iOS/mobile popover quirks / workarounds
├── qr.ts # QR encode/decode helpers
├── sigil/ # Low-level sigil encode/decode helpers (non-React)
└── sync/ # Synchronization helpers (feed/sigil sync, etc.)
These are framework-agnostic modules that can be reused from other clients.
src/pages/
├── SigilFeedPage.tsx / SigilFeedPage.css # ΦNet feed / stream of sigil events
├── VerifySigil.tsx # Route for verifying sigil payloads
├── PShort.tsx # Short URL / token landing page (e.g. /p~... links)
├── SigilPage/ # Full sigil detail route (subfolder)
└── sigilstream/ # Stream exploration routes/components
These tie together components into navigable routes for the SPA.
src/session/
├── SigilSessionTypes.ts # Types for session & payload
├── SigilSessionContext.ts # React context for active sigil session
├── useSigilSession.ts # Hook for reading/updating session
└── SigilSession.tsx # Provider component wrapping the app
Session here is not cookies/passwords — it’s sigil-driven state.
src/types/
├── global.d.ts # Global augmentations
├── klockTypes.ts # Kai-Klok specific types
├── sigil.ts # Sigil-related core types
├── crypto-shims.d.ts # Node/web crypto shims
├── jsqr.d.ts # QR library types
├── pako.d.ts # Compression lib types
├── snarkjs.d.ts # snarkjs raw types
├── snarkjs-shim.d.ts # snarkjs browser shim types
└── zkp-prover.d.ts # Prover interfaces
Plus a top-level src/types.ts for shared app-wide types.
src/utils/
├── constants.ts # Global constants (URLs, magic numbers, etc.)
├── kai_pulse.ts # Canonical Kai-Klok pulse engine
├── kai_turah.ts # Harmonic/Kai-Turah helpers
├── kai.ts # Kai utility surface (bridge helpers)
├── kaiMath.ts, kairosMath.ts # Math helpers for Kai/Kairos calculations
├── klock_adapters.ts # Bridge between Kai-Klok and UI / system time
├── phi-precision.ts # μΦ fixed-point arithmetic
├── phi-issuance.ts # Issuance logic, rules, constraints
├── cryptoLedger.ts # Client-side ledger / crypto helpers
├── provenance.ts # Provenance tracking and lineage logic
├── sigilDecode.ts # Decode sigil payloads
├── sigilRegistry.ts # Local registry of known sigils
├── sigilCapsule.ts # Encapsulated sigil payload form
├── sigilUrl.ts # Sigil URL building/parsing utilities
├── sigilAuthExtract.ts # Extract auth/context from sigil payloads
├── svgMeta.ts # SVG metadata handling for sigils
├── transferPackage.ts # Packaging of transfers (Φ + sigil + proofs)
├── sendLedger.ts # Client-to-ledger send helpers
├── sendLock.ts # Send lock coordination to avoid races
├── feedPayload.ts # Feed payload shaping and parsing
├── shareUrl.ts, shortener.ts, urlShort.ts # URL & share helpers (including /p~ tokens)
├── qrExport.ts # Export sigil/Φ data to QR
├── domHead.ts # Document head management (title/meta)
├── sanitizeHtml.ts # Clean user HTML (guards against XSS)
├── kopyFeedback.ts # Copy-to-clipboard UX helpers
├── solarSync.ts # Sync Kai-Solar mapping for clocks/kalendar
├── valuation.ts # Valuation and price computation helpers
├── globalTokenRegistry.ts # Registry of tokens seen/used in session
├── payload.ts # Canonical payload builder/parser
├── extractKaiMetadata.ts # Extract Kai metadata from sigils / payloads
├── useClientReady.ts # Hook for client-only logic (no SSR mismatch)
├── useSigilPayload.ts # Main sigil payload hook
└── useSigilPayload copy.ts # Legacy/backup (cleanup candidate)
This folder is the core protocol utility layer for the client: time, math, value, sigils, URLs, and sync.
src/verifier/
└── validator.ts # Core validation routines for sigil/Φ payloads
This is the non-UI brain for verification, consumed by the Verifier UI components.
Proof of Breath™ is a sovereign, cryptographic time protocol that deterministically seals identity, authorship, and value to the exact breath-indexed lattice of reality — not clock time.