npm package discovery and stats viewer.

Discover Tips

  • General search

    [free text search, go nuts!]

  • Package details

    pkg:[package-name]

  • User packages

    @[username]

Sponsor

Optimize Toolset

I’ve always been into building performant and accessible sites, but lately I’ve been taking it extremely seriously. So much so that I’ve been building a tool to help me optimize and monitor the sites that I build to make sure that I’m making an attempt to offer the best experience to those who visit them. If you’re into performant, accessible and SEO friendly sites, you might like it too! You can check it out at Optimize Toolset.

About

Hi, 👋, I’m Ryan Hefner  and I built this site for me, and you! The goal of this site was to provide an easy way for me to check the stats on my npm packages, both for prioritizing issues and updates, and to give me a little kick in the pants to keep up on stuff.

As I was building it, I realized that I was actually using the tool to build the tool, and figured I might as well put this out there and hopefully others will find it to be a fast and useful way to search and browse npm packages as I have.

If you’re interested in other things I’m working on, follow me on Twitter or check out the open source projects I’ve been publishing on GitHub.

I am also working on a Twitter bot for this site to tweet the most popular, newest, random packages from npm. Please follow that account now and it will start sending out packages soon–ish.

Open Software & Tools

This site wouldn’t be possible without the immense generosity and tireless efforts from the people who make contributions to the world and share their work via open source initiatives. Thank you 🙏

© 2026 – Pkg Stats / Ryan Hefner

@ancientpantheon/khronoton-core

v0.13.0

Published

Headless framework-agnostic scheduler engine: pure schedule math plus an injectable tick engine. No database, no job queue, no framework — hosts inject storage and firing via hooks.

Readme

@ancientpantheon/khronoton-core

The headless scheduler engine of the AncientPantheon stack — pure 7-mode schedule math plus an injectable tickOnce tick engine. Extracted from the AncientHoldings hub's inline scheduler ("Cronoton"), generalised into a framework-agnostic library: no database, no job queue, no framework. Hosts inject storage and firing behaviour via hooks; the engine only decides when things are due and what to fire.

Khronoton is the "When do I act?" Constructor of the Pantheon architecture — the heartbeat that separates an autonomous Automaton from a human-triggered Daimon. See the repo README for the full positioning.

Status

0.13.0 on public npmjs — MINOR. Released 2026-11-20. A cronoton can now express a chained, multi-step workflow ("drain→wrap→inject→evict"-shaped) as one schedulable unit instead of being limited to a single one-shot transaction. Three new tables (codex_cronoton_steps/codex_cronoton_runs/codex_cronoton_run_legs) back a non-blocking driver (runs-driver.ts's driveRunOnce/advanceInFlightRunsOnce, a third pass in startKhronotonLoop) built on a new non-blocking "submit" executor mode and a pure decision core (pure/run-advance.ts's advanceRun) that decides submit/poll/advance/re-plan/fail purely from a run's and its legs' current state. A new StepPlanner registry ships five built-in planners ported from OuronetUI's real transaction-construction logic — ouronet.aqp-evict, ouronet.aqp-inject, ouronet.aqp-unstall (backed by a newly-ported generic gas-probe-and-pack algorithm, pure/split-plan.ts), ouronet.stoa-wrap, and ouronet.stoa-unwrap — every one of which builds Pact code with zero interpolated values in the executed code itself. New executeNow chained-row support, a widened adaptMultiTxSummary, a standalone per-step POST .../steps/:index/{simulate,fire} route, and new GET /[id]/runs/GET /[id]/runs/[runId]/legs read routes round out the observability surface. A plain one-shot cronoton's behavior is completely unchanged. Reviewed via nectar across all seven phases of this feature plus one additional cross-phase round after they shipped (33 rounds total, 73 CONFIRMED findings): four CRITICAL findings surfaced across the arc — a missing Pact module-namespace prefix and a Pact-code-injection vulnerability (both caught before ever shipping, in round 1 of the ouronet.aqp-evict planner's own review), a run-gets-permanently-stuck bug found only in a follow-up cross-phase pass (a planner throw on a run's first drive left it stranded forever with no recovery path), and a regression in that very fix (an overly broad catch that turned a benign concurrency race into a false permanent failure), caught by re-reviewing the fix itself. Multiple HIGH findings were also found and fixed, including a standalone-fire route that could bypass the paused/terminal guard every other fire route enforces, a genuine concurrency race in the core driver (fixed with a new claim-before-submit mechanism), and a read-tier handler leaking real transaction amounts and account identifiers. 1265 specs pass.

0.12.0 on public npmjs — MINOR. Released 2026-11-11. Any codex-cronoton can now opt into a public, unauthenticated, token-gated observability view of its schedule, health, and fire history — the concrete driver being a UI that wants to embed a cronoton's next-fire time and recent executions on a public-facing page, without exposing the authenticated admin surface. New public_token/public_observable columns (added via a new ensureColumn upgrade helper — the first time installSchema has needed to add a column to an already-provisioned database, not just a fresh install); a new server/store/public.ts surface (setPublicObservable, getCodexCronotonByPublicToken, getCronotonFireCounts, deriveCronotonHealth, toPublicCronotonView); and a new handlers/public.ts publicCronotonHandler that deliberately never calls ctx.auth — gated purely on token validity plus the observable flag, with an unknown token and a known-but-non-observable token returning the identical 404. The sanitizing projector never includes pact_code, payload_json, signers_json, gas_payer_json, server_resolver, created_by, config_json, raw fire error text, or the internal row id — the public token is the only public identifier. 1027 specs pass.

0.11.0 on public npmjs — MINOR. Released 2026-09-17. Two independent handoffs, shipped together. Editor Save: an always-visible edit-mode SaveBar (Simulate + Save changes + live status) now renders on every tab, gated on the edited row having actually loaded so it can never fire a Simulate against a blank default state; the Execute tab's own Commit button is edit-aware ("Save changes"); a new shared useCommitGate(state, sim) hook keeps both surfaces reading the identical commit body and gate, computed once. Auto self-calibrating gas: autoGasLimit now defaults to true for new cronotons; ChainClient gains optional preflightRead (accurate gas via the SDK's preflight mode, replacing dirtyRead's execution-only measurement for AUTO fires) and getBlockGasLimit (a live block-ceiling fetch with a static fallback); a transaction whose measured gas exceeds the resolved ceiling is now refused with a structured error — never silently capped or submitted — for both AUTO and MANUAL fires, with the ceiling itself validated against NaN/non-finite/non-positive values before use. 980 specs pass.

0.10.0 on public npmjs — MINOR. Released 2026-09-08. The Builder's absolute "Gas Price (ANU)" field is gone: the UI now shows a read-only, live-refreshing "Live Network Floor" plus an editable "Priority Buffer (ANU above floor)" (default 0), and every fire prices as liveFloor(creationTime) + buffer. New optional CodexTxConfig.gasPriceBufferAnu (absent/pre-migration rows default to 0, self-healing with no DB migration); gasPrice stays, @deprecated, for reading historical rows. ChainRuntime.gasMeta gains an optional 2nd bufferAnu param (non-breaking) — the adapter sums floor+buffer in ANU before the one conversion, not two summed STOA floats. A negative/non-finite buffer can never underprice a fire — enforced at three layers: client validateConfig, the store's commitCodexCronoton/editCodexCronoton (reject before any write), and the seam's own defensive clamp. New useLiveGasFloor() hook polls every 30s plus visibilitychange/focus. BuilderConfig.gasPriceAnu and CommitGateOptions.minGasPriceAnu are removed (not deprecated-in-place) — both lost all meaning once there's no absolute price to floor-check. 938 specs pass (+5 real-runtime integration specs).

0.9.0 on public npmjs — MINOR. Released 2026-09-07. Scheduled transactions are now priced against the chain's live gas floor at fire time instead of a static value stored at creation time. A cronoton's gasPrice was persisted once at creation and read back verbatim on every tick, so as chainweb's post-fork Yin Engine floor rises, a long-lived cronoton silently drifts below it and its fire is rejected — with nobody watching a 3am tick. (Live, not theoretical: at release the floor was 11,569 ANU against a stored default of 10,000.) Adds an optional ChainRuntime.gasMeta(floorAnu) seam returning { creationTime, gasPrice } from one clock read; the stored price becomes a floor an operator can raise, never a cap, so existing rows self-heal with no migration. creationTime is now stamped explicitly from the same call that produced the price (it was previously auto-stamped by the Pact builder from a second, independent clock read), and the AUTO-gas rebuild re-derives both fresh. Transaction meta uses the precision-safe anuToStoaNumber rather than float division. A StoaChain fire on a runtime lacking gasMeta fails loudly rather than silently reusing the stale price. Requires a coordinated bump of @stoachain/stoa-core@^4.4.0, @stoachain/kadena-stoic-legacy@^4.4.0, @ouronet/ouronet-core@^4.6.0. 907 specs pass (+5 real-runtime integration specs).

0.8.0 on public npmjs — MINOR. Released 2026-08-03. Finalizes the evented-resolver UI. (1) The cronoton DETAIL card's "Schedule" field now reads "Evented" for a trigger-only/evented row (it previously showed the stored schedule like "Daily at 12:00 UTC" while Next Fire already read "—"); the list and detail now share one isTriggerOnly(row) predicate (external_fireable === 1 || runtime-arg keys) so they can't drift. (2) A system (server_resolver) cronoton is now deletable behind a confirm-gated warning instead of a hard 409: DELETE /[id]?force=1 permits the delete (the 409 still stands without force), threaded via ConfirmOpts.force + both reference adapters + the widened remove.run({ force }); the bundled Builder's Delete button is enabled for an admin on a system row and shows a warning naming the resolver before deleting, with the audit recording forced: true. Ordinary scheduled cronotons and non-forced deletes are unchanged. 893 specs pass.

0.7.0 on public npmjs — MINOR. Released 2026-08-03. Makes event-driven resolvers server-authoritative: SingleTxResolver/MultiTxResolver gain an evented? flag, and the store forces an evented resolver's cronoton scheduleless (next_fire_at = NULL, excluded from the due-query) and external_fireable = 1 even when a schedule is sent — the guarantee no longer depends on the consumer. Adds GET /resolvers (+ an OPTIONAL resolvers() adapter method and useServerResolvers hook) so the Builder learns which resolvers are evented; the list shows "Evented" as the next-fire for a trigger-only row; and the store enforces one resolver ↔ one cronoton (a second bind is rejected). Deliberately reverses 0.6.0's HMAC stance — an evented row is now HMAC-fireable — codifying Pythia's shipped behavior (see version history). 871 specs pass.

0.6.1 on public npmjs — PATCH. Released 2026-08-02. Fixes a crash that white-screened the Khronoton admin list whenever it held ≥1 cronoton: listCodexCronotons returned a camelCase 9-field projection while CronotonList renders full snake_case rows, so pact_code was undefined and crashed pactPreview. The list now returns full CodexCronotonRows (SELECT *, like getCodexCronoton) and pactPreview guards a missing pact_code. 850 specs pass.

0.6.0 on public npmjs — MINOR. Released 2026-08-02. Server resolvers can now declare themselves event-driven (ServerResolverOption.eventDriven): selecting one in the Builder commits the cronoton scheduler-off (next_fire_at = NULL, never auto-fired) and swaps the schedule editor for an event-driven notice — the host fires it in-process via the existing executeNow (not the HMAC endpoint). Ordinary scheduled resolvers are unchanged. 848 specs pass.

0.5.0 on public npmjs — MINOR. Released 2026-08-02. The Builder screen's Pact-code editor is now syntax-highlighted (via the package's --khr-* theme tokens, five new ones added), moved to a full-width top strip (~7 lines, internal scroll) with the header/tabs/tab content full-width below it, and gained a live tx-size/gas metering strip. @uiw/react-codemirror + the CodeMirror/Lezer packages it now depends on for highlighting are real optional peerDependencies. 832 specs pass.

0.4.2 on public npmjs — PATCH. Released 2026-07-22. Aligns the peerDependenciesMeta key with the @ouronet/ouronet-core peer renamed in 0.4.1 (the meta entry still named the old @stoachain peer). No code change. 799 specs pass.

0.4.1 on public npmjs — PATCH (dependency rename, no code change). Released 2026-07-22. @stoachain/ouronet-core → @ouronet/ouronet-core — same code, new scope, following the Phase-4 split into OuroborosNetwork/ouronet-libs. 799 specs pass.

0.4.0 on public npmjs — the complete drop-in codex-cronoton experience, matching the AncientHoldings Hub, now chain-polyglot. On top of the byte-unchanged root . schedule engine and /server automaton engine (both from 0.2.0), the package ships the whole experience layer as subpaths so a consumer wires the Hub's cronoton UX end to end without re-implementing it:

  • /handlers — framework-agnostic HTTP route handlers over the /server store + executor (list/get/fires/signers/commit/edit/pause/resume/delete/simulate/execute-now/trigger/batch/recover), driven by a tiny HandlerRequest/HandlerResponse seam so any router (Next.js, Express, …) can mount them.
  • /provider + /hooks — the React data layer: <KhronotonProvider adapter={…}>, the 16-method KhronotonAdapter seam with two reference adapters (createFetchAdapter over HTTP, createMemoryAdapter over in-process handlers), the shared runGated confirm-retry, and the data + action hooks (useCronotons/useCronoton/useCronotonFires/useManualBatch + the lifecycle/execute action hooks).
  • /ui + /ui.css — the React UI at full Hub parity: the four screens List, Detail/Observe (fire history with 50/page pager, definition-drift flag, result tooltip, pluggable multi-tx renderer, wired recover), Builder (syntax-highlighted Pact-code editor full-width on top, Config/Payload/Gas Payer/Signatures/Execute tabs full-width below, Simulate→AUTO-gas calibrate, a live tx-size/gas metering strip), and a Public read-only transparency view — themed entirely through --khr-* CSS variables inside <KhronotonUiRoot>.

Khronoton isn't chain-agnostic — it's chain-polyglot: the root schedule/tick engine orchestrates, and the /blockchain/<chain> subpath family teaches it to speak each supported chain's language natively (0.4.0):

  • /blockchain/stoachain — createStoachainRuntime(config?) wraps the @stoachain/* runtime into the core ChainRuntime seam, so a StoaChain automaton injects one object instead of reaching for @stoachain/* directly. Future chains land as sibling subpaths (/blockchain/<chain>).

Each chain's SDK is an optional peer dependency (@stoachain/* for /blockchain/stoachain), and the adapter imports it lazily — so npm install @ancientpantheon/khronoton-core pulls zero chain SDKs, and you carry only the SDK(s) for the chain(s) you actually import. It's one package, one version, one drop-in for every automaton. Likewise React is an optional peer for the /provider, /hooks, and /ui subpaths only. Every JS subpath resolves under both import conditions (ESM import + CJS require); the root ., /server, and /handlers outputs are byte-identical to 0.3.0/0.2.0.

Schedule engine

The engine exports pure functions over a discriminated ScheduleConfig union — no side effects, no clock reads, no randomness. You pass in the current time (now) explicitly; two calls with identical arguments always return identical results.

The 7 schedule modes

ScheduleMode is one of seven string literals, each paired with its own config shape:

| Mode | Config fields | Fires | | --- | --- | --- | | daily-at-utc | hours: number[], minute: number | At each listed UTC hour every day | | every-n-minutes | startDate: string (ISO), intervalMinutes: number | Every N minutes, anchored to startDate | | weekly | daysOfWeek: number[] (0–6), hour, minute | At the given UTC time on each listed weekday | | monthly | daysOfMonth: number[] (1–31), hour, minute | At the given UTC time on each listed day of month | | cron-expression | expression: string | Per the 5-field UTC cron expression (see below) | | one-time | fireAt: string (ISO) | Exactly once, then terminal | | several-times-per-day | times: { hour; minute }[] | At each listed UTC time-of-day, every day |

computeNextFire(mode, config, now)

computeNextFire(mode: ScheduleMode, config: ScheduleConfig, now: Date): Date | null

Returns the next instant strictly after now at which the schedule is due. The contract is TOTAL, MONOTONIC, and PURE:

  • TOTAL — a valid (mode, config, now) triple never throws; a malformed config throws InvalidScheduleConfigError. Recurring modes always yield a future Date. The terminal one-time mode yields null once its single fire is in the past (a valid result, not an error).
  • MONOTONIC — for the same recurring schedule, a later now yields an equal-or-later next-fire; every recurring mode iterates strictly forward from now.
  • PURE — no Math.random, no Date.now(); now is the explicit input.
import { computeNextFire } from '@ancientpantheon/khronoton-core';

computeNextFire(
  'daily-at-utc',
  { mode: 'daily-at-utc', hours: [12], minute: 0 },
  new Date('2026-06-01T00:00:00.000Z'),
); // → Date 2026-06-01T12:00:00.000Z

summariseSchedule(mode, config)

summariseSchedule(mode: ScheduleMode, config: ScheduleConfig): string

Returns a short human-readable description of a schedule (e.g. "One-time at 2026-07-01T12:00:00.000Z UTC"). Pure — it never reads Date.now() or the system locale.

In-tree cron parser

The cron-expression mode is backed by a pruned in-tree parser — no cron-parser dependency is added. It accepts the standard 5-field UTC shape minute hour dayOfMonth month dayOfWeek, with this per-field syntax:

| Syntax | Meaning | | --- | --- | | * | any value | | N | a literal integer | | N,M,... | a comma list | | N-M | an inclusive range | | */STEP | step from the field's start | | N/M | step from N |

Explicitly rejected (throws InvalidScheduleConfigError): @hourly/@daily and other @macro shorthands, a seconds field (6-field expressions), and the Quartz extensions L, W, and #.

dayOfMonth and dayOfWeek follow standard cron OR-matching when both are restricted: a day matches if it satisfies either field. A field written as its full range (1-31 for dayOfMonth, 0-6 for dayOfWeek) is detected as a wildcard, so the OR only applies when both fields are genuinely restricted.

Errors

InvalidScheduleConfigError is the single typed reject for malformed configs (out-of-range values, non-integer times, unparseable ISO instants, malformed cron expressions). Well-formed inputs never throw.

Tick engine

tickOnce(now, deps) walks the rows that are due at now and fires each once, delegating all host coupling to three injected hooks. It performs no storage, queue, clock, or framework access of its own — the host supplies those through deps. It calls computeNextFire internally to decide each row's next instant.

import { tickOnce } from '@ancientpantheon/khronoton-core';
import type { TickRow, TickResult, TickDeps } from '@ancientpantheon/khronoton-core';

tickOnce(now: Date, deps: TickDeps): TickResult

The three injected hooks

| Hook | Signature | Role | | --- | --- | --- | | loadDue | (now: Date) => TickRow[] | Return the rows due at now. A throw here propagates out of tickOnce (isolation is per-row, not batch-level). | | enqueueFire | (row: TickRow) => void | Dispatch the fire (queue/audit). Receives the host's full row object — the generic engine reads only id/mode/config, so any extra host fields ride along untouched. | | persistNextFire | (id: string, nextDate: Date, firedAt: Date) => void | Durably record the advance. firedAt is the tick's explicit now — never a clock read. |

A TickRow is { id: string; mode: ScheduleMode; config: ScheduleConfig | string }. Its config accepts both host forms: a typed ScheduleConfig object, or a JSON string that the engine parses per-row inside the isolated try (so one unparseable row is skipped, not the whole batch).

Result semantics

tickOnce returns { firedIds: string[]; skippedIds: string[] }:

  • Fired — a row's id lands in firedIds only when both enqueueFire and persistNextFire returned without throwing.
  • Skipped — every other processed outcome lands in skippedIds: an unparseable config, a computeNextFire rejection, a throwing hook, or a spent one-time schedule (computeNextFire → null, a valid terminal state, not an error and not logged).
  • The two sets are disjoint and together cover exactly the rows that were processed.

Guarantees

  • Enqueue strictly before persist, and persist runs only after enqueue succeeds. A crash between the two re-fires the row on the next tick rather than silently dropping it. An enqueueFire throw leaves persistNextFire uncalled for that row.
  • Per-row isolation — each row is processed in its own try; one bad row is logged and skipped, and the tick continues. No status or row mutation: the engine's only write channel is persistNextFire, whose signature cannot express a status change.
  • Batch cap — at most maxBatch rows are processed per tick (default 100), regardless of how many loadDue returns. Overflow rows appear in neither result set; they stay due and are re-read next tick. A provided maxBatch that is not a positive integer (0, negative, fractional, NaN) throws a RangeError before any hook runs — never a silent zero-batch or dropped-tail.
  • Synchronous — tickOnce returns a plain object, not a Promise. The engine holds no in-memory timers and carries no state across calls, so it is restart-safe: the host re-reads due state via loadDue each tick.

Optional deps

  • maxBatch?: number — override the default 100 (positive integer only; see above).
  • logError?: (message: string) => void — redirect skip logging; defaults to console.error.

Host preconditions

  1. The three hooks must themselves be synchronous. TypeScript's => void contextual typing silently accepts an async hook, but its returned Promise is neither awaited nor error-handled — an async hook voids the enqueue-before-persist ordering and the per-row-isolation guarantees. Async hosts are a future, separate additive API.
  2. loadDue must return at most one row per id. The fired/skipped disjoint-set semantics assume unique ids; behavior under duplicate ids is unspecified.
const result = tickOnce(new Date('2026-05-24T12:00:00.500Z'), {
  loadDue: () => [
    { id: 'r1', mode: 'daily-at-utc', config: { mode: 'daily-at-utc', hours: [12], minute: 0 } },
  ],
  enqueueFire: (row) => queue.push(row.id),
  persistNextFire: (id, nextDate, firedAt) => db.advance(id, nextDate, firedAt),
});
// → { firedIds: ['r1'], skippedIds: [] }; nextDate = 2026-05-25T12:00:00.000Z, firedAt = the passed now

What this package does NOT contain

Persistence, queues, timers, HTTP, or any framework binding — those stay in the host (the AncientHoldings hub keeps its own glue and imports this package for the scheduling logic). The tickOnce tick engine walks due schedules and invokes host hooks, but it never touches storage, queues, or clocks itself — the host injects all coupling through loadDue/enqueueFire/persistNextFire.

Server engine (/server)

The @ancientpantheon/khronoton-core/server subpath is the stand-alone automaton layer: everything needed to run scheduled, signed, on-chain firing on top of the root schedule engine. It ships no chain client, no database driver, and no framework — the host injects those through six seams. The root . import (pure schedule math + tickOnce) is byte-unchanged and carries no server dependency.

import {
  installSchema,
  codexCronotonTickOnce,
  processDueManualBatchesOnce,
  startKhronotonLoop,
  executeCodexTransaction,
  registerServerResolver,
  fireByServerResolver,
} from '@ancientpantheon/khronoton-core/server';

The six injection seams

The host provides these; the engine stays framework- and chain-agnostic:

  • KeyResolver — resolves a public key to a signing keypair (getKeyPairByPublicKey, listCodexPubs). This is where the codex signs.

  • ChainRuntime — the chain client + constants: a Pact builder, createClient(url) → { dirtyRead, submit, listen }, a universal signer, gas helpers (calculateAutoGasLimit, anuToStoa), and networkId / namespace / getPactUrl / gasStationAccount.

  • Database — a minimal structural handle (exec, prepare(...).run/get/all); a better-sqlite3 instance satisfies it structurally, but any driver of that shape works. Run installSchema(db) once to create the three tables.

  • onAudit — a sink called once per fire with { action, result, targetKind, targetId, detail }.

  • resolveFireMode — synchronous (cronotonId) => 'test' | 'live'; a per-row fire_mode_override='live' wins first.

  • Config — six optional knobs; each defaults when omitted:

    | Field | Default | Meaning | | --- | --- | --- | | tickIntervalMs | 30_000 | Loop interval | | listenTimeoutMs | 300_000 | Fire listen timeout | | autoGasCeiling | 2_000_000 | AUTO-gas pre-flight build ceiling | | singleTxGasGuard | 1_600_000 | Server-resolver single-tx gas guard | | tickBatchLimit | 100 | Rows claimed per tick | | manualBatch | { min: 2, max: 60, intervalSeconds: 60 } | Manual-batch bounds + spacing |

    (There is no gasPriceFloor or ttl knob — the executor uses each cronoton's own definition.config gas price and TTL directly.)

Exactly-once (claim-before-fire)

A due fire happens once and only once. Before firing, the tick issues an atomic conditional UPDATE that re-asserts the row is still due and advances its next_fire_at in the same statement; it fires only if that write claimed the row (changes === 1). Two overlapping ticks on the same row → the second claim is a no-op → no double-submit. This is the primary double-fire guard and needs no leader election; a multi-worker lease, if ever wanted, is the host's concern.

Wire-in recipe (Automaton host, e.g. Mnemosyne)

import Database from 'better-sqlite3';
import { installSchema, startKhronotonLoop } from '@ancientpantheon/khronoton-core/server';

const db = new Database('automaton.db');
db.pragma('foreign_keys = ON');
installSchema(db);

const ctx = {
  db,
  resolver,        // your KeyResolver adapter
  runtime,         // your ChainRuntime adapter
  onAudit,         // your audit sink
  resolveFireMode, // () => 'test' | 'live'
  config,          // full Config (or omit fields to take the defaults above)
};

const { stop } = startKhronotonLoop(ctx); // ticks every config.tickIntervalMs; call stop() to halt

API route contract (deferred)

This bump ships the engine only. Framework-agnostic HTTP handlers (create/edit/list/trigger/simulate a cronoton) are not included — a host writes thin routes over the exported store + executeCodexTransaction/fireByServerResolver surface. The route contract is documented for that; concrete handlers arrive in a later bump.

Node floor

The /server subpath's CJS require condition relies on Node's require(esm) support (Node ≥ 20.19 / ≥ 22.12), the same mechanism as the root's 0.1.1 require condition — so the effective Node floor for CommonJS consumers is ≥ 20.19. The package engines field stays >=20 (unchanged), matching the root.

Public observability (public_token / publicCronotonHandler) — since 0.12.0

Every cronoton can opt into a public, unauthenticated, read-only view of its own state — schedule, status, health, and complete fire history — for a host that wants to embed "next mint at…" + recent executions on a public-facing page without exposing its authenticated admin surface at all. Off by default. Nothing is public until an admin explicitly flips it on for that one cronoton.

1. Opt a cronoton in (admin-side, through your own authenticated route — this call has no auth of its own, same as every other /server store function):

import { setPublicObservable } from '@ancientpantheon/khronoton-core/server';

const { publicToken } = setPublicObservable(cronotonId, { observable: true }, { db });
// publicToken is minted ONCE, the first time a row goes observable, and is
// STABLE across later observable:false -> observable:true toggles (so an
// embed URL built from it never has to be re-minted). Pass
// { observable: true, regenerate: true } to force a fresh token instead
// (e.g. if the old one leaked). { observable: false } hides the cronoton
// again WITHOUT clearing the stored token, so re-enabling reuses it.

Build your public embed URL from publicToken — it's an opaque, 160-bit (crypto.randomBytes(20), base64url) string, not the cronoton's internal id. The internal id never appears anywhere in the public surface.

2. Mount the route (host-side, any router — this one handler is the entire public surface):

import { publicCronotonHandler } from '@ancientpantheon/khronoton-core/handlers';

// e.g. a Next.js API route: pages/api/public/cronoton/[token].ts
export default async function handler(req, res) {
  const result = await publicCronotonHandler(
    { db, runtime, resolver, auth: yourAuthSeam }, // auth is REQUIRED by the
                                                     // HandlerContext type but
                                                     // is NEVER actually called
                                                     // by this one handler —
                                                     // any AuthSeam satisfies it
    { params: { token: req.query.token }, query: req.query },
  );
  // YOUR responsibility, not this package's: Cache-Control + CORS.
  res.setHeader('Cache-Control', 'public, max-age=30');
  res.setHeader('Access-Control-Allow-Origin', '*'); // or your embed's origin
  res.status(result.status).json(result.body);
}

Unlike every other handler in /handlers, publicCronotonHandler deliberately never calls ctx.auth — that's not an oversight, it's the whole point: this route's trust boundary is "does this token resolve to an observable row," entirely independent of whatever your admin AuthSeam would otherwise require. An unknown token and a known-but-currently-disabled token return the identical 404 { error: "not found" } — the two cases are indistinguishable on purpose, so a probing request can never learn whether a given token ever existed.

3. The response, for a known, currently-observable token:

{
  "ok": true,
  "name": "DailyStoicismMint",
  "description": "Mints the daily Stoicism allotment",
  "status": "active",                 // active | paused | completed | error
  "schedule": { "mode": "daily-at-utc", "humanText": "Daily at 18:00 UTC" },
  "triggerOnly": false,                // true = fires on demand (event/HMAC/runtime-arg), no timer
  "nextFireAt": "2026-11-11T18:00:00.000Z",
  "lastFireAt": "2026-11-10T18:00:00.000Z",
  "isOverdue": false,                  // active + scheduled + nextFireAt already passed
  "since": "2026-01-01T00:00:00.000Z", // row's created_at
  "counts": {
    "fired": 42, "succeeded": 41, "failed": 1,
    "lastSuccessAt": "...", "lastFailureAt": "...",
    "currentFailStreak": 0,            // consecutive failures ending at the most recent fire
    "successRatePercent": 98
  },
  "health": "healthy",                 // healthy | degraded | down — derived traffic light
  "fires": {
    "page": [
      { "firedAt": "...", "status": "success", "chainId": "0", "requestKey": "...", "txKeys": [], "recoveredAt": null, "mode": "live" }
    ],
    "total": 42, "limit": 50, "offset": 0  // ?limit=&offset= page the COMPLETE history, not just "last 20"
  }
}

Never present, under any circumstances: pact_code, payload_json, signers_json, gas_payer_json, server_resolver, created_by, config_json, a fire's raw errorMessage/chainResponse, or the internal row id. A fire's status already says "failure" when relevant — no raw error text ever ships alongside it. See src/server/store/public.ts's toPublicCronotonView for the one place this guarantee is enforced (it builds the response field-by-field and never spreads the underlying row/fire objects).

health is a simple derived traffic light, not a new source of truth: "down" once currentFailStreak hits 3, "degraded" at 1–2 or whenever isOverdue is true, "healthy" otherwise — call deriveCronotonHealth yourself if you need the same rule outside this response shape.

Install

npm install @ancientpantheon/khronoton-core

Version history

v0.13.0 — Chained multi-step cronoton runs. A cronoton was always exactly one scheduled Pact transaction; a workflow needing several transactions in sequence — some fanning out into a variable number of legs decided only at fire time — had no way to express itself as a single schedulable unit. This release adds that capability end to end, fully additive, across what was built and reviewed as seven sequential phases plus a follow-up cross-phase review. Non-blocking submit. The scheduler's tick awaits a fire's confirmation inline inside a single running-boolean-guarded pass (server/loop.ts) — fine for one transaction, impossible for a multi-leg chained run (serially awaiting four legs could freeze the entire scheduler for up to twenty minutes). A third executeCodexTransaction mode, "submit", builds/signs/preflights/submits and returns without ever calling listenWithTimeout; runFire's build-through-submit internals were extracted into a shared submitTransaction helper with zero change to fire's own external behavior (its existing test suite runs unmodified as the proof). A new optional ChainClient.pollRequestKeys(keys, chainId) seam (implemented in blockchain/stoachain.ts over Kadena's batch /poll) polls every outstanding request key on a chain in one HTTP call per tick, not one per leg. Schema. Three new tables: codex_cronoton_steps (a cronoton's static step definitions, mode: 'single' | 'planner', a CHECK enforcing exactly one shape is filled), codex_cronoton_runs (status: 'planning' | 'awaiting' | 'advancing' | 'succeeded' | 'failed' | 'abandoned', step_index/step_count, deadline_at, attempt, with a partial UNIQUE index self-blocking a second non-terminal run per cronoton at the DB layer — a second createRun attempt throws a typed RunAlreadyInFlightError, never a raw constraint leak), and codex_cronoton_run_legs (status: 'pending' | 'submitted' | 'confirmed' | 'failed', request_key, attempt as a generation marker, and a claimed_at lease column added partway through the arc to close a concurrency race — see below). A leg row is always written pending before any submission, mirroring the existing claim-before-fire discipline one level down; store functions (store/runs.ts/store/steps.ts) are decision-free CRUD, with every typed-error gap (StepAlreadyExistsError, RunLegAlreadyExistsError, LegNotSubmittedError) caught and closed during review, and a shared isUniqueConstraintError helper (store/errors.ts) replacing what review caught as a verbatim-duplicated copy between the two store files. Pure decision core (pure/run-advance.ts). advanceRun(run, legs, now, policy) is a stateless function returning one or more of six actions (submit-leg, poll, advance-step, replan-step, fail-run, wait) from a fixed-order decision table: a met barrier is checked before a passed deadline (confirmed legs always win); a serial step's mid-sequence failure re-plans immediately (a cursor-paged sequence's later legs become suspect the moment one fails); a parallel step's failure waits for every sibling leg to reach a terminal status first (the "3 of 4 confirm, one fails" case re-plans only once that picture is complete, never on the first failure). A cross-cutting invariant test (tests/chained-run-invariants.test.ts) proves advance-step is never returned unless every current-step leg is confirmed. The driver (runs-driver.ts). driveRunOnce/advanceInFlightRunsOnce execute advanceRun's actions against the store and chain client, wired into startKhronotonLoop as a third pass (codexCronotonTickOnce's own claimed-due-row loop branches into a create-run-and-submit-step-0 path for any row with ≥1 step row, reusing driveRunOnce for both "just created" and "Nth pass" rather than a second decision path). The schedule's own next_fire_at keeps advancing on every due tick regardless of a long-lived run's self-block — two deliberately independent clocks, proven end to end against a real in-memory DB. A prerequisite fix (generation-scoped legs: the previously-unwritten attempt column used as a generation marker, plus a new bumpRunAttempt store write) makes a genuine re-plan after a failure actually work — without it, a step whose barrier check filters on step_index alone would be permanently defeated the instant any leg ever failed once; this retroactively corrected a latent gap in ouronet.aqp-evict's own re-plan path, not just the planners added afterward. Five built-in planners, registered through a new StepPlanner registry (registerStepPlanner/getStepPlanner, a plain module-level map mirroring the existing server-resolver registry precedent), ported faithfully from OuronetUI's real transaction-construction logic across a workspace boundary: ouronet.aqp-evict reads an on-chain URHC_BuildEvictPlans plan, tries one simulated CC_FullEvictRewards leg first, and fans out to one CC_EvictSingleReward leg per beneficiary only on an actual gas-ceiling refusal; ouronet.aqp-inject tries CC_InjectFinalize then CC_Inject and — unlike the human-facing UI flow it replaces — never fans out and never refuses, propagating a genuine error if both attempts fail, since there's no human in the loop to hand a refusal to; ouronet.aqp-unstall fans stale-member-score repair into CCp_FvtFixSlice batches sized by a newly-ported generic gas-probe-and-pack algorithm (pure/split-plan.ts's measureSize/planFromSizing/splitPlan, ported verbatim from OuronetUI's measureSplit.ts including its two-probe sizing, shrink-and-retry confirmation loop, and secant-refit growth loop); ouronet.stoa-wrap and ouronet.stoa-unwrap exist as built-ins because hand-authoring a Pact signer capability's scope correctly is the dangerous part, independent of leg count — stoa-wrap reads the patron account's live STOA balance via coin.get-balance immediately before building its one leg (rather than trusting any inter-step-carried value) and returns [] rather than a doomed zero-amount leg when the balance is 0; stoa-unwrap conditionally composes a coin.C_CreateAccount + LQD|C_UnwrapStoa two-form transaction only when its target account probe shows it doesn't exist yet. Every planner builds Pact code with zero interpolated values in the executed code itself — every dynamic value flows through transaction payload and a read-string/read-integer/read-msg/read-decimal/read-keyset placeholder; only a leg's signer capabilities string is a documented, narrowly-scoped exception, made safe by shape-guarding every account string before it reaches either payload or capability line. Observability and standalone fire. executeNow (handlers/execute.ts) now recognizes a chained row (≥1 codex_cronoton_steps row), starts a real run via createRun+driveRunOnce, and returns a real HTTP 409 when a non-terminal run is already in flight. adaptMultiTxSummary (server/resolvers.ts) widens its existing duck-typed extraction to read an optional per-batch ok field (via a dedicated toReportedOk helper, never a naive Boolean() coercion) and reports genuine multi-tx failure instead of hardcoding ok: true — strictly additive. A new handlers/steps.ts adds POST /cronotons/:id/steps/:index/simulate and POST /cronotons/:id/steps/:index/fire, resolving a stored step by index (byte-identical leg construction to a real run, sharing stepRowToDefinition/a new shared resolvePlannerFor helper rather than reimplementing either) and deliberately bypassing the run/leg-table lifecycle — a preview/testing mechanism, not an alternate production fire path — behind the same confirm gate executeNow uses, correctly rejecting a fire (but not a simulate) against a paused or terminal cronoton. New GET /[id]/runs (paginated, newest-first) and GET /[id]/runs/[runId]/legs (404 if the run belongs to a different cronoton) make a run's full lifecycle and every leg's fire/confirm history visible through this package's own surface for the first time, with per-leg signers/capability data redacted from the response. A genuine concurrency race, found and fixed in already-shipped Phase 3 code. driveRunOnce was only ever called from inside the scheduler loop's own single-process re-entrancy guard until executeNow's new chained-row branch invoked it directly from an HTTP handler — making a previously-deferred, previously-documented gap in runs-driver.ts's own doc comment concretely reachable: the background sweep could pick up the same newly-created run and both callers could read and submit the same pending leg before either write landed. Fixed with a real claim-before-submit step: a new nullable claimed_at column on codex_cronoton_run_legs plus claimLegForSubmit/releaseLegClaim (a conditional UPDATE ... WHERE status='pending' AND claimed_at IS NULL, mirroring the existing due-row claim idiom one level down), proven by an end-to-end test driving two concurrent driveRunOnce calls on the same run and asserting the real chain submit happens exactly once. A follow-up cross-phase review, run after all six phases shipped and everything was green, found three more significant bugs no single phase's own review could see: a CRITICAL stuck-run bug (a planner throw on a run's very first drive — every real planner's first action is a live chain read, so a bad params blob, a genuine Pact failure, or a transient chain outage all trigger it — left the run permanently non-terminal, since deadline_at is never stamped before that point and no code path ever marked the run terminal, blocking that cronoton's one-run-at-a-time slot forever with no recovery short of direct DB surgery); a HIGH leak of real transfer amounts, account identifiers, and Pact capability lines through the read-tier runLegsHandler (now redacted, mirroring toPublicCronotonView's field-by-field convention); and a HIGH uncached live getBlockGasLimit() fetch repeated on every leg submit and planner probe within a single driver pass, serialized behind the loop's single re-entrancy guard and so delaying every other scheduled fire in the same tick (now cached per chain with a short TTL). A dedicated terminal re-review of the CRITICAL fix then caught a real regression in it — the new terminalize-on-throw catch was broader than intended, turning a benign concurrent-insert race into a permanent run failure and silently discarding the replan retry budget on a transient re-plan error — fixed by narrowing the catch to only the genuinely-unrecoverable first-entry case. Reviewed via nectar across all seven phases of this feature plus the cross-phase round — 33 rounds total, correctness/conventions/tests on every phase plus a security lens from Phase 3 onward (a funds-moving automaton porting real transaction-construction and signer-capability logic across a workspace boundary), 73 CONFIRMED findings fixed (or resolved via documentation where that was the proportionate response — e.g. a lease-expiry edge case on the new claim mechanism, accepted as a bounded, already-self-recovering limitation rather than rushed new reconciliation machinery), 4 REFUTED on adversarial validation, 2 downgraded to STYLISTIC. One further real bug — binary-floating-point noise leaking into a signed capability line and transaction payload for realistic token balances — was caught only by behavioral verification against the real built artifact using a real measured value from the source handoff; no lens pass or unit test (all of which used clean round numbers) found it. Full history in docs/work/khronoton-chained-runs/review.md, its six phase-numbered siblings, and docs/work/khronoton-chained-runs-cross-phase-review/review.md. Released 2026-11-20. 1265 specs pass.

v0.12.0 — Opt-in public cronoton observability. A cronoton's state (schedule, status, fire history, success/fail counts) was previously visible only through the authenticated admin surface (listHandler/getHandler/firesHandler behind withRead + the host's AuthSeam) — nothing let a host expose one cronoton's state to an unauthenticated, cross-origin caller (the concrete driver: embedding a mint's next-fire time + recent executions in a public-facing page), and this is framed as a general capability, not a one-off. Schema. Two new codex_cronotons columns: public_token TEXT (unique, nullable) and public_observable INTEGER NOT NULL DEFAULT 0 (off by default). SQLite has no ALTER TABLE ... ADD COLUMN IF NOT EXISTS, so installSchema (server/schema.ts) gains a small reusable ensureColumn(db, table, column, columnDefSql) helper (PRAGMA table_info → conditional ALTER TABLE ADD COLUMN), called once for each new column, immediately after CREATE TABLE IF NOT EXISTS — the FIRST time this package has needed to add a column to an already-provisioned database rather than just a fresh install, since the same call handles both a brand-new DB (the columns are absent from the CREATE TABLE literal) and an existing host's DB identically. A CREATE UNIQUE INDEX IF NOT EXISTS idx_codex_cronotons_public_token follows — SQLite's unique index already permits multiple NULLs, so non-observable rows with no token never collide. Store (server/store/public.ts). setPublicObservable(id, { observable, regenerate? }, dep) toggles public_observable and mints public_token lazily: once, the first time a row is made observable (crypto.randomBytes(20).toString("base64url")), and never again on a plain disable→re-enable toggle — stable, so an embed URL built from the token never needs re-minting; regenerate: true is the only way to force a new one. A call against an unknown id throws the existing CodexCronotonValidationError("not found") — no new error type. getCodexCronotonByPublicToken(token, dep) resolves a row with one query (WHERE public_token = ? AND public_observable = 1), so an unknown token and a known-but-non-observable token are indistinguishable — both null — matching the "never 403, never leak which" rule one layer up in the handler. getCronotonFireCounts(id, dep) computes whole-history aggregates independently of any paginated fires window (a page of 20 out of 150 fires would under-report every aggregate): one query for fired/succeeded/failed/lastSuccessAt/lastFailureAt, plus a DESC-ordered scan (capped at 1000 rows) counting leading 'failure' statuses for currentFailStreak — the scan stops at the first non-failure, so a success anywhere further back in the history never dilutes the trailing streak count. deriveCronotonHealth({ currentFailStreak, isOverdue }) is a pure, standalone traffic-light rule: "down" at a streak ≥ 3, "degraded" at 1–2 or when overdue, "healthy" otherwise. toPublicCronotonView(row, counts, firesPage, now?) is the sanitizing projector and the ONLY place the privacy guarantee is enforced — it builds the DTO field-by-field from the row/fires, never spreading either, so pact_code, payload_json, signers_json, gas_payer_json, server_resolver, created_by, config_json, a fire's raw errorMessage/chainResponse, and the internal row id can never ride along by accident; the public token is the only public identifier the view carries. The view includes schedule.humanText (via summariseSchedule) and schedule.cron only for a cron-expression row, triggerOnly (reusing rowExternalFireable), isOverdue (true only for an active row whose next_fire_at has passed — overdue only makes sense for a row the scheduler is actually ticking), and a fires page whose total/limit/offset are passed through from listFires verbatim, not recomputed. Handler (handlers/public.ts). publicCronotonHandler(ctx, request), added to the barrel, is a framework-agnostic GET /<token> route that is unauthenticated by design — it never calls ctx.auth/withRead/withConfirm at all, a deliberately different trust tier than the admin gates, authorizing purely on token validity plus the public_observable flag. Returns { status: 404, body: { error: "not found" } } for both an unknown token and a known-but-non-observable one (byte-identical, never distinguishable), 200 with the sanitized view otherwise. limit/offset are parsed from request.query with a local, file-private copy of read.ts's firesHandler clamp (1..100, default 50) — read.ts's own clampInt/firstScalar are module-private, so this is a deliberate duplicate rather than a cross-handler import — over the cronoton's complete fire history, not a fixed "last 20": a cronoton with 150 fires is fully reachable across repeated calls with increasing offset, and fires.total always reports 150 regardless of the requested window. Cache-Control and CORS stay entirely host-side, unchanged package convention (HandlerResponse carries no headers field). Entirely additive — no existing export, column default, or admin-surface response shape changes for a cronoton that never opts in. Reviewed via nectar across 4 rounds (correctness/conventions/security/tests lenses each round, adversarial validation throughout, 16 CONFIRMED findings total, zero REFUTED, zero STYLISTIC): round 1 (7 findings) caught the two most significant — a triggerOnly gap that missed a plain-eventDriven cronoton (no persisted column distinguishes it; fixed by gating on next_fire_at === null excluding terminal one-time rows) and a clamp-default mismatch (the handler's own doc comment and CHANGELOG claimed parity with the admin firesHandler's default of 50 while actually defaulting to 20) — plus an ORDER BY tiebreak gap, a modified_at omission, and two test-coverage gaps; round 2 re-verified round 1's fixes and caught that the triggerOnly fix's own comment asserted a false invariant (claimDueCodexCronoton also nulls next_fire_at on an ordinary row, not just the terminal-intent writer), plus two more test gaps; round 3 found the round-1 ORDER BY tiebreak itself was wrong — it sorted on the fire row's random crypto.randomUUID() id instead of a chronological key, fixed to SQLite's implicit rowid — plus two more test-coverage gaps; round 4 added a mapStoreError safety net this one unauthenticated handler had been missing (every sibling handler gets it for free from withRead/withConfirm) and closed the last two test gaps (health's wiring inside the projector, and the fail-streak's 1000-row cap); round 5 found that round 4's own safety net had a real (if narrow) hole — a malformed chain_response_json row's JSON.parse failure was uncaught in server/store/fires.ts's shared listFires (unlike its sibling parseTxKeys, which already tolerated bad input), and Node 20+'s V8 embeds a snippet of the actual malformed input text in that error's message — which mapStoreError's generic passthrough would then have forwarded verbatim into the public route's 500 body, bypassing toPublicCronotonView's sanitization entirely. Fixed at the root (fires.ts gains the same try/catch-degrade-to-null guard as parseTxKeys, benefiting every current and future caller of listFires, not just this one route) rather than only patched at this one call site. Full history in docs/work/public-cronoton-observability/review.md. Released 2026-11-11. 1027 specs pass.

v0.11.0 — Discoverable edit-mode Save + auto self-calibrating gas. Two independent handoffs built and shipped together. Editor Save. Editing an existing cronoton had no discoverable Save — the only action was the "Commit Codex Cronoton" button on the last (Execute) tab, silently disabled under AUTO gas until a Simulate ran, with the reason invisible from any other tab. Adds an always-visible edit-mode SaveBar (ui/builder/SaveBar.tsx) — Simulate, Save changes, and a live status line — rendered above the Pact editor/tabs on every tab, gated on Builder.tsx's editReady (the edited row having actually finished loading) so it can never fire a Simulate against the blank default makeEmptyBuilderState() during the load window. The Execute tab's own Commit button is now edit-aware ("Save changes" / "Saving…"); create mode is byte-identical to before. A new shared useCommitGate(state, sim) hook (ui/builder/use-commit-gate.ts), extracted from ExecuteTab.tsx's own prior inline logic, is called ONCE in Builder.tsx and threaded as commit/gate props to both SaveBar and ExecuteTab — no risk of two independent builderToCommit/canCommit call sites drifting apart, and no duplicate computation on every keystroke when both are mounted. Both of SaveBar's buttons are canMutate(access)-gated in their CLICK HANDLERS, not just their disabled attribute (a directly-dispatched click event still reaches a React handler regardless of the DOM disabled state). Auto self-calibrating gas. Khronoton transactions defaulted to a fixed, manually-set gas limit, so fires over-reserved gas wildly — a real pool-payout fire measured 594 gas used against a 600,000 limit. makeEmptyBuilderState()'s config.autoGasLimit now defaults to true. ChainClient (server/seams.ts) gains two new optional methods: preflightRead — implemented in blockchain/stoachain.ts via the SDK's raw local(tx, {preflight:true, signatureVerification:false}), NOT its .preflight convenience alias (which also forces signatureVerification:true) — measures the TRUE gas including the transaction-size charge that plain dirtyRead omits; getBlockGasLimit does a best-effort /config fetch (mirroring OuronetUI's gas-limits.ts, ported without its browser-oriented module-level mutable-singleton cache — this package fetches fresh per fire instead, since a Node server core handling concurrent fires can't safely share that kind of global state) falling back to the existing static AUTO_GAS_CEILING on any failure. executor.ts's runSimulate/runFire were reordered so the ChainClient is constructed BEFORE ceiling resolution (ceiling resolution needs it) — a real sequencing fix, not just an addition. AUTO-gas fires now calibrate from preflightRead; a runtime missing it hard-throws on an AUTO-gas fire only (mirroring the 0.9.0 gasMeta precedent — silent fallback would ship the exact over-reservation bug this exists to fix), while a MANUAL-gas fire on the same un-upgraded runtime is completely unaffected. A new refuse-unmineable check returns a structured {ok:false, error} — never a silent cap, never a submit — when measured gas exceeds the resolved ceiling, for BOTH AUTO and MANUAL fires. The ceiling itself (from either the live fetch or an explicit Config.autoGasCeiling override) is validated via a new isSaneCeiling check (Number.isFinite && > 0) before use — NaN in particular would otherwise silently defeat the refuse check entirely, since every gasUsed > NaN comparison is false in JS. Reviewed via nectar (2 rounds, 5 lenses then a targeted 2-lens re-pass, adversarial validation throughout): 9 CONFIRMED findings fixed, including two initially-HIGH findings (the SaveBar pre-load readiness gap; its originally-unguarded Simulate click) validated down to MEDIUM once the actual blast radius was traced against the code (Save itself stayed correctly disabled during the load window; the server independently re-authorizes via its own withConfirm/auth.requireConfirm gate regardless of what the UI allows). Full history in docs/work/khronoton-editor-save-and-auto-gas/review.md. Released 2026-09-17. 980 specs pass.

v0.10.0 — Locked live-floor gas + priority buffer. 0.9.0 made the executor floor a stored absolute price against the live Yin Engine floor so a fire could no longer underprice, but the Builder UI still framed gas price as something an operator sets — the wrong model for a recurring transaction, since any absolute number typed today is guaranteed to go stale as the live floor keeps rising every ~3h. This finishes the redesign: the UI shows a read-only, live-refreshing "Live Network Floor" display plus an editable "Priority Buffer (ANU above floor)" (default 0), and every fire prices as liveFloor(creationTime) + buffer, derived fresh at build time — never a cached/stored absolute value. Schema. CodexTxConfig gains optional gasPriceBufferAnu; gasPrice stays, @deprecated, read-only, so historical config_json still parses — absence (every pre-migration row) defaults to 0, self-healing with no DB migration. Seam. ChainRuntime.gasMeta(floorAnu, bufferAnu?) — the buffer is a new optional 2nd parameter (non-breaking: TypeScript accepts a shorter existing implementation as satisfying the widened optional signature). The adapter (blockchain/stoachain.ts) sums floorAnu + bufferAnu in ANU, inside the adapter, before the one anuToStoaNumber conversion at the end — summing two independently-converted STOA floats instead produces a different serialized value in roughly 1 in 5 floor/buffer pairs, reintroducing the exact precision bug 0.9.0 fixed. buildTransaction always calls gasMeta(0, config.gasPriceBufferAnu ?? 0) now — there is no more stored absolute value to raise to a floor, so the seam's first argument is always 0. Defense in depth. A negative or non-finite buffer can never underprice a fire, enforced at three independent layers: ui/builder-state.ts's validateConfig blocks commit client-side; server/store/cronoton.ts's commitCodexCronoton/editCodexCronoton reject a present-and-invalid gasPriceBufferAnu before any write, so a caller reaching the store directly (bypassing the Builder UI) can't persist a row that silently underprices every future fire; and blockchain/stoachain.ts's gasMeta clamps a bad buffer to 0 as a third line of defense for any CodexTxDefinition built outside the store entirely. Live display. New useLiveGasFloor() hook (ui/builder/live-gas-floor.ts) polls the live floor every 30s plus a visibilitychange/focus refresh — browsers throttle setInterval in backgrounded tabs, and this Builder screen is routinely left open for hours — called once in Builder.tsx, threaded to ConfigTab and ExecuteTab. Precision fix applied a second place. ui/tx-size.ts's size estimator now uses the same floor+buffer-summed-in-ANU-then-converted-once formula the executor uses, instead of the deprecated absolute gasPrice. Breaking at the UI-type layer. BuilderConfig.gasPriceAnu and CommitGateOptions.minGasPriceAnu are removed, not deprecated-in-place — both lose all meaning once there is no absolute price to floor-check against, and keeping them would be actively misleading; CodexTxConfig itself stays additive. Reviewed via nectar across 3 rounds (5 lenses each, adversarial validation): round 1 found and fixed a HIGH gap (server-side validation of the buffer was entirely absent) plus 5 lower-severity test-coverage/UI gaps; round 2 re-verified those fixes and caught 3 more small issues (a misleading UI label, duplicated validation logic, a test-loop robustness nit); round 3 caught one last barrel-export asymmetry — all fixed, full history in docs/work/gas-price-buffer/review.md. Released 2026-09-08. 938 specs pass (+5 real-runtime integration specs).

v0.9.0 — Live gas floor at fire time. buildTransaction priced every fire off definition.config.gasPrice, a plain ANU number persisted in codex_cronotons at creation time and read back verbatim on every tick (server/tick.ts, server/store/mappers.ts) — never re-derived. Post-fork, chainweb-node validates a signed transaction's price against the rising Yin Engine floor as of that transaction's own creationTime, so a cronoton created at the builder's 10,000 ANU default is already underpriced and drifts further as it ages; because this is unattended automation, the rejection surfaces at 3am with nobody watching. The seam. ChainRuntime gains an optional gasMeta(floorAnu): { creationTime, gasPrice }. Optional keeps the package chain-POLYGLOT and @stoachain/* an optional peer dependency — a chain without a rising floor omits it — but the executor hard throws when a StoaChain fire finds it missing, because a silent fallback to the stored value would ship the original bug to anyone who did not notice they must upgrade their adapter. In fire mode that throw is caught by the existing F-002 wrapper and returned as a structured { ok: false, error }, so a one-time entry still records its spent attempt instead of re-firing forever. Floor, not cap. The implementation returns max(storedAnu, minGasPriceAnu(creationTime)), so an operator may still price above the minimum and existing stored rows self-heal with no database migration. One clock read. setMeta previously omitted creationTime entirely, letting the Pact builder auto-stamp its own at createTransaction() — an independent second read the price no longer corresponded to. Both fields now come from a single stoaGasMeta()-derived call, and the AUTO-gas calibrated rebuild+re-sign re-enters the seam rather than reusing the pre-flight values, so the two builds cannot straddle a 3-hour tick boundary and underprice the transaction that actually ships (pinned by a regression spec that fails if the call is hoisted out of buildTransaction). Precision. Transaction meta now converts via anuToStoaNumber (exact padded-decimal) instead of anuToStoa (float division), which upstream documents as unsafe for a value chainweb hashes and validates exactly; the same fix lands in ui/tx-size.ts's fee meter, whose purpose is predicting the real signed transaction's byte size. Builder gate. validateConfig accepts CommitGateOptions.minGasPriceAnu in place of a hardcoded >= 10000 check that accepted already-underpriced values, and names the applied floor in its message; omitting it falls back to the genesis floor, under-rejecting rather than over-rejecting since the executor raises the price at fire time regardless. Boundary. blockchain/stoachain.ts is the only module that knows the Yin Engine exists, wrapping @stoachain/stoa-core/gas rather than reimplementing a formula already independently reimplemented four times across the ecosystem; /server stays free of any @stoachain/* import. Requires a coordinated dependency bump — stoa-core 4.4.0 peer-pins kadena-stoic-legacy 4.4.0 exactly, and only ouronet-core 4.6.0 accepts stoa-core 4.4.0, so the three move together. All new surface (StoaGasMeta, ChainRuntime.gasMeta, CommitGateOptions.minGasPriceAnu) is additive. Released 2026-09-07. 907 specs pass (+5 real-runtime integration specs).

v0.8.0 — Finalizes the evented-resolver UI (the last two gaps after 0.7.0). Fix 1 — DETAIL "Schedule" reads "Evented". The read-only cronoton detail card rendered the stored schedule_config (e.g. "Daily at 12:00 UTC") for a trigger-only/evented row even though Next Fire already showed "—" and the edit form already disabled the scheduler; root cause was Detail.tsx deriving triggerOnly from runtime-arg keys only, ignoring external_fireable. The list's predicate is extracted to a shared isTriggerOnly(row) (row.external_fireable === 1 || parseRuntimeArgKeys(row.runtime_arg_keys).length > 0) in ui/row-derive.ts, used by both the list next-fire cell and the detail Schedule cell so they can't drift; the detail Schedule cell now reads "Evented" for a trigger-only row. Fix 2 — confirm-gated system delete. DELETE /[id] hard-refused any server_resolver ("system") cronoton with 409 { protected: true }; it now accepts ?force=1 (still behind the admin confirm gate) to permit the delete, while the 409 stands without force. Threaded end-to-end: ConfirmOpts.force → createFetchAdapter sends ?force=1 / createMemoryAdapter passes query: { force: "1" } → the widened DeleteAction/remove.run({ force }) action hook. In the bundled Builder, deleteDisabled now enables the Delete button for an admin on a system cronoton (non-admins still blocked), and both the detail and list handleDelete show a deleteSystemConfirm warning naming the resolver — "This is the automaton's <name> template. Deleting it stops that capability until it's recreated. Delete anyway?" — as the first prompt, keeping the existing in-gate password confirm. The delete audit is preserved and records forced: true for a forced system delete. Ordinary scheduled cronotons, non-system deletes, and delete(id)/remove.run() without force are byte-identical to 0.7.0; a system delete without force still 409s. All new surface (ConfirmOpts.force, DeleteRunOpts, deleteSystemConfirm, row-derive's isTriggerOnly) is additive. Released 2026-08-03. 893 specs pass.

v0.7.0 — Server-authoritativ