@smthrs/engine-store 0.0.0-stage → 1.0.0-rc.3

package/dist/cjs/EngineStoreMetrics.d.ts

@@ -0,0 +1,276 @@
+/**
+ * Standard metric definitions for the engine-store hot paths.
+ *
+ * This module only defines the metric handles, following the shape of
+ * `RunStoreMetrics` and Effect's `ClusterMetrics`. The dispatch seam
+ * (`internal/ActionPersistence`), the plan scheduler, the workspace sandbox,
+ * and the run driver update them as outcomes are decided. No exporter ships in
+ * this package; provide one — for example `@smthrs/observability` — and
+ * these series appear in it.
+ *
+ * Counters over an effect's exit are keyed by {@link ExitTag} records, so an
+ * update is a lookup rather than a branch, and durations land in
+ * `Metric.timer` histograms through Effect's own `Effect.trackDuration`. The
+ * same exit observation annotates the operation span with its outcome; none of
+ * the instrumentation combinators alters the instrumented effect's result or
+ * cause.
+ *
+ * @since 0.1.0
+ */
+import type * as Duration from "effect/Duration";
+import * as Effect from "effect/Effect";
+import type * as Exit from "effect/Exit";
+import * as Metric from "effect/Metric";
+/**
+ * How an instrumented effect exited: `Success`, `Failure` (any non-interrupt
+ * cause), or `Interrupt` (an interrupt-only cause — in this store that is the
+ * fencing self-interruption as well as caller cancellation).
+ *
+ * @category models
+ * @since 0.1.0
+ */
+export type ExitTag = "Success" | "Failure" | "Interrupt";
+/**
+ * Classifies an exit for an {@link ExitTag}-keyed counter record.
+ *
+ * @category accessors
+ * @since 0.1.0
+ */
+export declare const exitTag: <A, E>(exit: Exit.Exit<A, E>) => ExitTag;
+/**
+ * Observes an effect with a duration timer and an exit-outcome counter.
+ *
+ * Composes Effect's own `Effect.trackDuration` (monotonic clock, records on
+ * success, failure, and interruption alike) with an `Effect.onExit` counter
+ * update and current-span annotation, so the instrumented effect's exit —
+ * value, cause, and interruption — propagates byte-identically. This is the
+ * dual-instrument shape production Effect services use for hot-path
+ * operations.
+ *
+ * @category combinators
+ * @since 0.1.0
+ */
+export declare const observe: (instruments: {
+    readonly timer: Metric.Histogram<Duration.Duration>;
+    readonly counter: { readonly [Tag in ExitTag]: Metric.Metric<number, Metric.CounterState<number>>; };
+}) => <A, E, R>(effect: Effect.Effect<A, E, R>) => Effect.Effect<A, E, R>;
+/**
+ * Counter over durable action dispatches through
+ * `internal/ActionPersistence`, dimensioned by exit `outcome` (`success`,
+ * `failure`, or `interrupt`). A cache-served replay and a fresh execution
+ * both count: the dispatch is the unit the engine retries and fences.
+ *
+ * @category metrics
+ * @since 0.1.0
+ */
+export declare const dispatches: Metric.Counter<number>;
+/**
+ * Latency histogram over durable action dispatches, from admission through
+ * settlement (cache verification, execution, copy-back, and the terminal
+ * row included).
+ *
+ * @category metrics
+ * @since 0.1.0
+ */
+export declare const dispatchDuration: Metric.Histogram<Duration.Duration>;
+/**
+ * `dispatches` views keyed by {@link ExitTag}.
+ *
+ * @category metrics
+ * @since 0.1.0
+ */
+export declare const dispatch: {
+    readonly Success: Metric.Metric<number, Metric.CounterState<number>>;
+    readonly Failure: Metric.Metric<number, Metric.CounterState<number>>;
+    readonly Interrupt: Metric.Metric<number, Metric.CounterState<number>>;
+};
+/**
+ * Counter over scheduler admission passes that launched work. The
+ * completion-driven scheduler re-computes the ready set after every terminal
+ * event; only a pass that admits at least one node counts, so the series
+ * reads as "how many times the scheduler opened dispatch permits", not as
+ * event-loop noise.
+ *
+ * @category metrics
+ * @since 0.1.0
+ */
+export declare const schedulerAdmissions: Metric.Counter<number>;
+/**
+ * Latency histogram over one scheduler dispatch, admission through terminal
+ * event: measurement, keying, the durable-action seam, and every rebase turn
+ * of the same node's loop land in a single observation.
+ *
+ * @category metrics
+ * @since 0.1.0
+ */
+export declare const schedulerDispatchDuration: Metric.Histogram<Duration.Duration>;
+/**
+ * Counter over plan node settlements, dimensioned by the scheduler `outcome`
+ * (`built`, `clean`, `failed`, `skipped`, or `deferred`) — the per-node
+ * evaluation vocabulary `PlanScheduler` journals.
+ *
+ * @category metrics
+ * @since 0.1.0
+ */
+export declare const schedulerNodes: Metric.Counter<number>;
+/**
+ * `schedulerNodes` views keyed by `PlanScheduler.Outcome`.
+ *
+ * @category metrics
+ * @since 0.1.0
+ */
+export declare const node: {
+    readonly deferred: Metric.Metric<number, Metric.CounterState<number>>;
+    readonly failed: Metric.Metric<number, Metric.CounterState<number>>;
+    readonly built: Metric.Metric<number, Metric.CounterState<number>>;
+    readonly clean: Metric.Metric<number, Metric.CounterState<number>>;
+    readonly skipped: Metric.Metric<number, Metric.CounterState<number>>;
+};
+/**
+ * Counter over isolated workspace executions (`WorkspaceSandbox.execute`),
+ * dimensioned by exit `outcome`. An `Invalidated` verdict is a `success`
+ * exit — the transaction ran and answered; the verdict itself is journaled.
+ *
+ * @category metrics
+ * @since 0.1.0
+ */
+export declare const sandboxExecutions: Metric.Counter<number>;
+/**
+ * `sandboxExecutions` views keyed by {@link ExitTag}.
+ *
+ * @category metrics
+ * @since 0.1.0
+ */
+export declare const sandboxExecution: {
+    readonly Success: Metric.Metric<number, Metric.CounterState<number>>;
+    readonly Failure: Metric.Metric<number, Metric.CounterState<number>>;
+    readonly Interrupt: Metric.Metric<number, Metric.CounterState<number>>;
+};
+/**
+ * Latency histogram over isolated workspace executions.
+ *
+ * @category metrics
+ * @since 0.1.0
+ */
+export declare const sandboxExecutionDuration: Metric.Histogram<Duration.Duration>;
+/**
+ * Counter over sandbox materializations (`WorkspaceSandbox.materialize` —
+ * the one host write), dimensioned by exit `outcome`.
+ *
+ * @category metrics
+ * @since 0.1.0
+ */
+export declare const sandboxMaterializations: Metric.Counter<number>;
+/**
+ * `sandboxMaterializations` views keyed by {@link ExitTag}.
+ *
+ * @category metrics
+ * @since 0.1.0
+ */
+export declare const materialization: {
+    readonly Success: Metric.Metric<number, Metric.CounterState<number>>;
+    readonly Failure: Metric.Metric<number, Metric.CounterState<number>>;
+    readonly Interrupt: Metric.Metric<number, Metric.CounterState<number>>;
+};
+/**
+ * Latency histogram over sandbox materializations.
+ *
+ * @category metrics
+ * @since 0.1.0
+ */
+export declare const materializationDuration: Metric.Histogram<Duration.Duration>;
+/**
+ * Counter over copy-back compare-and-set refusals: the preflight found host
+ * state that moved after the transaction's base snapshot. The engine answers
+ * one with a rebase or a conflict strategy, so the rate is contention
+ * evidence, not an error rate.
+ *
+ * @category metrics
+ * @since 0.1.0
+ */
+export declare const materializationConflicts: Metric.Counter<number>;
+/**
+ * Counter over step-boundary settlements at the dispatch seam, dimensioned by
+ * `outcome`: `clean` evidence, an `expected`-mode `deviation`, or a hard
+ * `violation` (undeclared write, missing declared output, surviving declared
+ * removal), with `refused` for a host that could not settle at all.
+ *
+ * @category metrics
+ * @since 0.1.0
+ */
+export declare const boundarySettlements: Metric.Counter<number>;
+/**
+ * `boundarySettlements` views keyed by settlement classification.
+ *
+ * @category metrics
+ * @since 0.1.0
+ */
+export declare const boundarySettlement: {
+    readonly Clean: Metric.Metric<number, Metric.CounterState<number>>;
+    readonly Deviation: Metric.Metric<number, Metric.CounterState<number>>;
+    readonly Violation: Metric.Metric<number, Metric.CounterState<number>>;
+    readonly Refused: Metric.Metric<number, Metric.CounterState<number>>;
+};
+/**
+ * Counter over the EFFECTIVE step-boundary cache decisions at the dispatch
+ * seam, dimensioned by `outcome`. `flows_step_cache_lookups` counts raw row
+ * presence at `CacheStore.get`; this series records what the dispatch
+ * actually did with the row after read-set verification and output
+ * materialization — `verified_hit` served the cached result, and every other
+ * outcome fell through to a real execution (`miss` no row,
+ * `unverifiable_evidence` a row whose recorded evidence cannot justify reuse,
+ * `unmeasurable` a host that could not re-measure the read set,
+ * `stale_read_set` a measured mismatch, `replay_failed` verified evidence the
+ * host could not re-materialize). Each decision is counted where it takes
+ * effect: `verified_hit` as the cached result is returned, a fall-through
+ * outcome as the dispatch proceeds past its refusal handling — so a
+ * cache-consulting dispatch that fails or is fenced out mid-decision (a
+ * journal failure on the provenance emit, a strict corruption verdict)
+ * records no decision, and its exit lands in {@link dispatches}. At most one
+ * decision is counted per cache-consulting dispatch.
+ *
+ * @category metrics
+ * @since 0.1.0
+ */
+export declare const stepCacheDecisions: Metric.Counter<number>;
+/**
+ * `stepCacheDecisions` views keyed by decision.
+ *
+ * @category metrics
+ * @since 0.1.0
+ */
+export declare const stepCacheDecision: {
+    readonly VerifiedHit: Metric.Metric<number, Metric.CounterState<number>>;
+    readonly Miss: Metric.Metric<number, Metric.CounterState<number>>;
+    readonly UnverifiableEvidence: Metric.Metric<number, Metric.CounterState<number>>;
+    readonly Unmeasurable: Metric.Metric<number, Metric.CounterState<number>>;
+    readonly StaleReadSet: Metric.Metric<number, Metric.CounterState<number>>;
+    readonly ReplayFailed: Metric.Metric<number, Metric.CounterState<number>>;
+};
+/**
+ * Counter over the run driver's claim-and-activate decisions, dimensioned by
+ * `outcome`. These are the engine-level decisions taken BEFORE or AFTER the
+ * store-level compare-and-swaps `RunStoreMetrics` counts: a `terminal` or
+ * `heartbeat_fresh` refusal never reaches the store, `steal_refused_owner_alive`
+ * is the liveness probe declining, and `claim_lost`/`activation_lost` are the
+ * driver observing a lost store CAS.
+ *
+ * @category metrics
+ * @since 0.1.0
+ */
+export declare const claims: Metric.Counter<number>;
+/**
+ * `claims` views keyed by driver decision.
+ *
+ * @category metrics
+ * @since 0.1.0
+ */
+export declare const claim: {
+    readonly Activated: Metric.Metric<number, Metric.CounterState<number>>;
+    readonly HeartbeatFresh: Metric.Metric<number, Metric.CounterState<number>>;
+    readonly ClaimLost: Metric.Metric<number, Metric.CounterState<number>>;
+    readonly Terminal: Metric.Metric<number, Metric.CounterState<number>>;
+    readonly StealRefusedOwnerAlive: Metric.Metric<number, Metric.CounterState<number>>;
+    readonly ActivationLost: Metric.Metric<number, Metric.CounterState<number>>;
+};
+//# sourceMappingURL=EngineStoreMetrics.d.ts.map

package/dist/cjs/EngineStoreMetrics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EngineStoreMetrics.d.ts","sourceRoot":"","sources":["../../src/EngineStoreMetrics.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAGH,OAAO,KAAK,KAAK,QAAQ,MAAM,iBAAiB,CAAA;AAChD,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,KAAK,IAAI,MAAM,aAAa,CAAA;AACxC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AAEvC;;;;;;;GAOG;AACH,MAAM,MAAM,OAAO,GAAG,SAAS,GAAG,SAAS,GAAG,WAAW,CAAA;AAezD;;;;;GAKG;AACH,eAAO,MAAM,OAAO,GAAI,CAAC,EAAE,CAAC,EAAE,MAAM,IAAI,CAAC,IAAI,CAAC,CAAC,EAAE,CAAC,CAAC,KAAG,OAC+C,CAAA;AAErG;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,OAAO,GAAI,aAAa;IACnC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,SAAS,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAA;IACnD,QAAQ,CAAC,OAAO,EAAE,EAAE,QAAQ,EAAE,GAAG,IAAI,OAAO,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,YAAY,CAAC,MAAM,CAAC,CAAC,GAAE,CAAA;CACpG,MACA,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,QAAQ,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,KAAG,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAS7D,CAAA;AAIH;;;;;;;;GAQG;AACH,eAAO,MAAM,UAAU,wBAErB,CAAA;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,qCAE3B,CAAA;AAEF;;;;;GAKG;AACH,eAAO,MAAM,QAAQ;;;;CAAsC,CAAA;AAE3D;;;;;;;;;GASG;AACH,eAAO,MAAM,mBAAmB,wBAE9B,CAAA;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,yBAAyB,qCAEpC,CAAA;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc,wBAEzB,CAAA;AAEF;;;;;GAKG;AACH,eAAO,MAAM,IAAI;;;;;;CAIhB,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,wBAE5B,CAAA;AAEF;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB;;;;CAA6C,CAAA;AAE1E;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,qCAEnC,CAAA;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,uBAAuB,wBAElC,CAAA;AAEF;;;;;GAKG;AACH,eAAO,MAAM,eAAe;;;;CAAmD,CAAA;AAE/E;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,qCAElC,CAAA;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,wBAAwB,wBAEnC,CAAA;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,mBAAmB,wBAE9B,CAAA;AAEF;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB;;;;;CAI9B,CAAA;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,kBAAkB,wBAE7B,CAAA;AAEF;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB;;;;;;;CAI7B,CAAA;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,MAAM,wBAEjB,CAAA;AAEF;;;;;GAKG;AACH,eAAO,MAAM,KAAK;;;;;;;CAIjB,CAAA"}

package/dist/cjs/EngineStoreMetrics.js

@@ -0,0 +1,135 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var EngineStoreMetrics_exports = {};
+__export(EngineStoreMetrics_exports, {
+  boundarySettlement: () => boundarySettlement,
+  boundarySettlements: () => boundarySettlements,
+  claim: () => claim,
+  claims: () => claims,
+  dispatch: () => dispatch,
+  dispatchDuration: () => dispatchDuration,
+  dispatches: () => dispatches,
+  exitTag: () => exitTag,
+  materialization: () => materialization,
+  materializationConflicts: () => materializationConflicts,
+  materializationDuration: () => materializationDuration,
+  node: () => node,
+  observe: () => observe,
+  sandboxExecution: () => sandboxExecution,
+  sandboxExecutionDuration: () => sandboxExecutionDuration,
+  sandboxExecutions: () => sandboxExecutions,
+  sandboxMaterializations: () => sandboxMaterializations,
+  schedulerAdmissions: () => schedulerAdmissions,
+  schedulerDispatchDuration: () => schedulerDispatchDuration,
+  schedulerNodes: () => schedulerNodes,
+  stepCacheDecision: () => stepCacheDecision,
+  stepCacheDecisions: () => stepCacheDecisions
+});
+module.exports = __toCommonJS(EngineStoreMetrics_exports);
+var Cause = __toESM(require("effect/Cause"), 1);
+var Effect = __toESM(require("effect/Effect"), 1);
+var Metric = __toESM(require("effect/Metric"), 1);
+const attributeValue = (tag) => tag.replace(/(?<=[a-z0-9])(?=[A-Z])/g, "_").toLowerCase();
+const byOutcome = (metric, attributes, tags) => Object.fromEntries(
+  tags.map((tag) => [tag, Metric.withAttributes(metric, { ...attributes, outcome: attributeValue(tag) })])
+);
+const exitTag = (exit) => exit._tag === "Success" ? "Success" : Cause.hasInterruptsOnly(exit.cause) ? "Interrupt" : "Failure";
+const observe = (instruments) => (effect) => effect.pipe(
+  Effect.trackDuration(instruments.timer),
+  Effect.onExit((exit) => {
+    const tag = exitTag(exit);
+    return Effect.annotateCurrentSpan({ outcome: attributeValue(tag) }).pipe(
+      Effect.andThen(Metric.update(instruments.counter[tag], 1))
+    );
+  })
+);
+const exitTags = ["Success", "Failure", "Interrupt"];
+const dispatches = Metric.counter("flows_engine_dispatches", {
+  description: "Durable action dispatches by exit outcome"
+});
+const dispatchDuration = Metric.timer("flows_engine_dispatch_duration", {
+  description: "Durable action dispatch duration"
+});
+const dispatch = byOutcome(dispatches, {}, exitTags);
+const schedulerAdmissions = Metric.counter("flows_engine_scheduler_admissions", {
+  description: "Plan scheduler admission passes that launched at least one dispatch"
+});
+const schedulerDispatchDuration = Metric.timer("flows_engine_scheduler_dispatch_duration", {
+  description: "Duration of one scheduler dispatch, admission through terminal event"
+});
+const schedulerNodes = Metric.counter("flows_engine_scheduler_nodes", {
+  description: "Plan node settlements by evaluation outcome"
+});
+const node = byOutcome(
+  schedulerNodes,
+  {},
+  ["built", "clean", "failed", "skipped", "deferred"]
+);
+const sandboxExecutions = Metric.counter("flows_engine_sandbox_executions", {
+  description: "Isolated workspace executions by exit outcome"
+});
+const sandboxExecution = byOutcome(sandboxExecutions, {}, exitTags);
+const sandboxExecutionDuration = Metric.timer("flows_engine_sandbox_execution_duration", {
+  description: "Isolated workspace execution duration"
+});
+const sandboxMaterializations = Metric.counter("flows_engine_sandbox_materializations", {
+  description: "Sandbox copy-back materializations by exit outcome"
+});
+const materialization = byOutcome(sandboxMaterializations, {}, exitTags);
+const materializationDuration = Metric.timer("flows_engine_sandbox_materialization_duration", {
+  description: "Sandbox copy-back materialization duration"
+});
+const materializationConflicts = Metric.counter("flows_engine_sandbox_conflicts", {
+  description: "Sandbox copy-back compare-and-set refusals"
+});
+const boundarySettlements = Metric.counter("flows_engine_boundary_settlements", {
+  description: "Step boundary settlements by outcome"
+});
+const boundarySettlement = byOutcome(
+  boundarySettlements,
+  {},
+  ["Clean", "Deviation", "Violation", "Refused"]
+);
+const stepCacheDecisions = Metric.counter("flows_engine_step_cache_decisions", {
+  description: "Effective step-boundary cache decisions at the dispatch seam"
+});
+const stepCacheDecision = byOutcome(
+  stepCacheDecisions,
+  {},
+  ["VerifiedHit", "Miss", "UnverifiableEvidence", "Unmeasurable", "StaleReadSet", "ReplayFailed"]
+);
+const claims = Metric.counter("flows_engine_claims", {
+  description: "Run driver claim-and-activate decisions by outcome"
+});
+const claim = byOutcome(
+  claims,
+  {},
+  ["Activated", "Terminal", "HeartbeatFresh", "StealRefusedOwnerAlive", "ClaimLost", "ActivationLost"]
+);
+//# sourceMappingURL=EngineStoreMetrics.js.map

package/dist/cjs/EngineStoreMetrics.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/EngineStoreMetrics.ts"],
+  "sourcesContent": ["/**\n * Standard metric definitions for the engine-store hot paths.\n *\n * This module only defines the metric handles, following the shape of\n * `RunStoreMetrics` and Effect's `ClusterMetrics`. The dispatch seam\n * (`internal/ActionPersistence`), the plan scheduler, the workspace sandbox,\n * and the run driver update them as outcomes are decided. No exporter ships in\n * this package; provide one \u2014 for example `@smthrs/observability` \u2014 and\n * these series appear in it.\n *\n * Counters over an effect's exit are keyed by {@link ExitTag} records, so an\n * update is a lookup rather than a branch, and durations land in\n * `Metric.timer` histograms through Effect's own `Effect.trackDuration`. The\n * same exit observation annotates the operation span with its outcome; none of\n * the instrumentation combinators alters the instrumented effect's result or\n * cause.\n *\n * @since 0.1.0\n */\n\nimport * as Cause from \"effect/Cause\"\nimport type * as Duration from \"effect/Duration\"\nimport * as Effect from \"effect/Effect\"\nimport type * as Exit from \"effect/Exit\"\nimport * as Metric from \"effect/Metric\"\n\n/**\n * How an instrumented effect exited: `Success`, `Failure` (any non-interrupt\n * cause), or `Interrupt` (an interrupt-only cause \u2014 in this store that is the\n * fencing self-interruption as well as caller cancellation).\n *\n * @category models\n * @since 0.1.0\n */\nexport type ExitTag = \"Success\" | \"Failure\" | \"Interrupt\"\n\n/** Rewrites an outcome tag (`HeartbeatFresh`) as an attribute value (`heartbeat_fresh`). */\nconst attributeValue = (tag: string): string => tag.replace(/(?<=[a-z0-9])(?=[A-Z])/g, \"_\").toLowerCase()\n\n/** Builds the tag-keyed record of attributed counter views for one operation. */\nconst byOutcome = <const Tags extends ReadonlyArray<string>>(\n  metric: Metric.Metric<number, Metric.CounterState<number>>,\n  attributes: Readonly<Record<string, string>>,\n  tags: Tags\n): { readonly [Tag in Tags[number]]: Metric.Metric<number, Metric.CounterState<number>> } =>\n  Object.fromEntries(\n    tags.map((tag) => [tag, Metric.withAttributes(metric, { ...attributes, outcome: attributeValue(tag) })])\n  ) as { [Tag in Tags[number]]: Metric.Metric<number, Metric.CounterState<number>> }\n\n/**\n * Classifies an exit for an {@link ExitTag}-keyed counter record.\n *\n * @category accessors\n * @since 0.1.0\n */\nexport const exitTag = <A, E>(exit: Exit.Exit<A, E>): ExitTag =>\n  exit._tag === \"Success\" ? \"Success\" : Cause.hasInterruptsOnly(exit.cause) ? \"Interrupt\" : \"Failure\"\n\n/**\n * Observes an effect with a duration timer and an exit-outcome counter.\n *\n * Composes Effect's own `Effect.trackDuration` (monotonic clock, records on\n * success, failure, and interruption alike) with an `Effect.onExit` counter\n * update and current-span annotation, so the instrumented effect's exit \u2014\n * value, cause, and interruption \u2014 propagates byte-identically. This is the\n * dual-instrument shape production Effect services use for hot-path\n * operations.\n *\n * @category combinators\n * @since 0.1.0\n */\nexport const observe = (instruments: {\n  readonly timer: Metric.Histogram<Duration.Duration>\n  readonly counter: { readonly [Tag in ExitTag]: Metric.Metric<number, Metric.CounterState<number>> }\n}) =>\n<A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R> =>\n  effect.pipe(\n    Effect.trackDuration(instruments.timer),\n    Effect.onExit((exit) => {\n      const tag = exitTag(exit)\n      return Effect.annotateCurrentSpan({ outcome: attributeValue(tag) }).pipe(\n        Effect.andThen(Metric.update(instruments.counter[tag], 1))\n      )\n    })\n  )\n\nconst exitTags = [\"Success\", \"Failure\", \"Interrupt\"] as const\n\n/**\n * Counter over durable action dispatches through\n * `internal/ActionPersistence`, dimensioned by exit `outcome` (`success`,\n * `failure`, or `interrupt`). A cache-served replay and a fresh execution\n * both count: the dispatch is the unit the engine retries and fences.\n *\n * @category metrics\n * @since 0.1.0\n */\nexport const dispatches = Metric.counter(\"flows_engine_dispatches\", {\n  description: \"Durable action dispatches by exit outcome\"\n})\n\n/**\n * Latency histogram over durable action dispatches, from admission through\n * settlement (cache verification, execution, copy-back, and the terminal\n * row included).\n *\n * @category metrics\n * @since 0.1.0\n */\nexport const dispatchDuration = Metric.timer(\"flows_engine_dispatch_duration\", {\n  description: \"Durable action dispatch duration\"\n})\n\n/**\n * `dispatches` views keyed by {@link ExitTag}.\n *\n * @category metrics\n * @since 0.1.0\n */\nexport const dispatch = byOutcome(dispatches, {}, exitTags)\n\n/**\n * Counter over scheduler admission passes that launched work. The\n * completion-driven scheduler re-computes the ready set after every terminal\n * event; only a pass that admits at least one node counts, so the series\n * reads as \"how many times the scheduler opened dispatch permits\", not as\n * event-loop noise.\n *\n * @category metrics\n * @since 0.1.0\n */\nexport const schedulerAdmissions = Metric.counter(\"flows_engine_scheduler_admissions\", {\n  description: \"Plan scheduler admission passes that launched at least one dispatch\"\n})\n\n/**\n * Latency histogram over one scheduler dispatch, admission through terminal\n * event: measurement, keying, the durable-action seam, and every rebase turn\n * of the same node's loop land in a single observation.\n *\n * @category metrics\n * @since 0.1.0\n */\nexport const schedulerDispatchDuration = Metric.timer(\"flows_engine_scheduler_dispatch_duration\", {\n  description: \"Duration of one scheduler dispatch, admission through terminal event\"\n})\n\n/**\n * Counter over plan node settlements, dimensioned by the scheduler `outcome`\n * (`built`, `clean`, `failed`, `skipped`, or `deferred`) \u2014 the per-node\n * evaluation vocabulary `PlanScheduler` journals.\n *\n * @category metrics\n * @since 0.1.0\n */\nexport const schedulerNodes = Metric.counter(\"flows_engine_scheduler_nodes\", {\n  description: \"Plan node settlements by evaluation outcome\"\n})\n\n/**\n * `schedulerNodes` views keyed by `PlanScheduler.Outcome`.\n *\n * @category metrics\n * @since 0.1.0\n */\nexport const node = byOutcome(\n  schedulerNodes,\n  {},\n  [\"built\", \"clean\", \"failed\", \"skipped\", \"deferred\"] as const\n)\n\n/**\n * Counter over isolated workspace executions (`WorkspaceSandbox.execute`),\n * dimensioned by exit `outcome`. An `Invalidated` verdict is a `success`\n * exit \u2014 the transaction ran and answered; the verdict itself is journaled.\n *\n * @category metrics\n * @since 0.1.0\n */\nexport const sandboxExecutions = Metric.counter(\"flows_engine_sandbox_executions\", {\n  description: \"Isolated workspace executions by exit outcome\"\n})\n\n/**\n * `sandboxExecutions` views keyed by {@link ExitTag}.\n *\n * @category metrics\n * @since 0.1.0\n */\nexport const sandboxExecution = byOutcome(sandboxExecutions, {}, exitTags)\n\n/**\n * Latency histogram over isolated workspace executions.\n *\n * @category metrics\n * @since 0.1.0\n */\nexport const sandboxExecutionDuration = Metric.timer(\"flows_engine_sandbox_execution_duration\", {\n  description: \"Isolated workspace execution duration\"\n})\n\n/**\n * Counter over sandbox materializations (`WorkspaceSandbox.materialize` \u2014\n * the one host write), dimensioned by exit `outcome`.\n *\n * @category metrics\n * @since 0.1.0\n */\nexport const sandboxMaterializations = Metric.counter(\"flows_engine_sandbox_materializations\", {\n  description: \"Sandbox copy-back materializations by exit outcome\"\n})\n\n/**\n * `sandboxMaterializations` views keyed by {@link ExitTag}.\n *\n * @category metrics\n * @since 0.1.0\n */\nexport const materialization = byOutcome(sandboxMaterializations, {}, exitTags)\n\n/**\n * Latency histogram over sandbox materializations.\n *\n * @category metrics\n * @since 0.1.0\n */\nexport const materializationDuration = Metric.timer(\"flows_engine_sandbox_materialization_duration\", {\n  description: \"Sandbox copy-back materialization duration\"\n})\n\n/**\n * Counter over copy-back compare-and-set refusals: the preflight found host\n * state that moved after the transaction's base snapshot. The engine answers\n * one with a rebase or a conflict strategy, so the rate is contention\n * evidence, not an error rate.\n *\n * @category metrics\n * @since 0.1.0\n */\nexport const materializationConflicts = Metric.counter(\"flows_engine_sandbox_conflicts\", {\n  description: \"Sandbox copy-back compare-and-set refusals\"\n})\n\n/**\n * Counter over step-boundary settlements at the dispatch seam, dimensioned by\n * `outcome`: `clean` evidence, an `expected`-mode `deviation`, or a hard\n * `violation` (undeclared write, missing declared output, surviving declared\n * removal), with `refused` for a host that could not settle at all.\n *\n * @category metrics\n * @since 0.1.0\n */\nexport const boundarySettlements = Metric.counter(\"flows_engine_boundary_settlements\", {\n  description: \"Step boundary settlements by outcome\"\n})\n\n/**\n * `boundarySettlements` views keyed by settlement classification.\n *\n * @category metrics\n * @since 0.1.0\n */\nexport const boundarySettlement = byOutcome(\n  boundarySettlements,\n  {},\n  [\"Clean\", \"Deviation\", \"Violation\", \"Refused\"] as const\n)\n\n/**\n * Counter over the EFFECTIVE step-boundary cache decisions at the dispatch\n * seam, dimensioned by `outcome`. `flows_step_cache_lookups` counts raw row\n * presence at `CacheStore.get`; this series records what the dispatch\n * actually did with the row after read-set verification and output\n * materialization \u2014 `verified_hit` served the cached result, and every other\n * outcome fell through to a real execution (`miss` no row,\n * `unverifiable_evidence` a row whose recorded evidence cannot justify reuse,\n * `unmeasurable` a host that could not re-measure the read set,\n * `stale_read_set` a measured mismatch, `replay_failed` verified evidence the\n * host could not re-materialize). Each decision is counted where it takes\n * effect: `verified_hit` as the cached result is returned, a fall-through\n * outcome as the dispatch proceeds past its refusal handling \u2014 so a\n * cache-consulting dispatch that fails or is fenced out mid-decision (a\n * journal failure on the provenance emit, a strict corruption verdict)\n * records no decision, and its exit lands in {@link dispatches}. At most one\n * decision is counted per cache-consulting dispatch.\n *\n * @category metrics\n * @since 0.1.0\n */\nexport const stepCacheDecisions = Metric.counter(\"flows_engine_step_cache_decisions\", {\n  description: \"Effective step-boundary cache decisions at the dispatch seam\"\n})\n\n/**\n * `stepCacheDecisions` views keyed by decision.\n *\n * @category metrics\n * @since 0.1.0\n */\nexport const stepCacheDecision = byOutcome(\n  stepCacheDecisions,\n  {},\n  [\"VerifiedHit\", \"Miss\", \"UnverifiableEvidence\", \"Unmeasurable\", \"StaleReadSet\", \"ReplayFailed\"] as const\n)\n\n/**\n * Counter over the run driver's claim-and-activate decisions, dimensioned by\n * `outcome`. These are the engine-level decisions taken BEFORE or AFTER the\n * store-level compare-and-swaps `RunStoreMetrics` counts: a `terminal` or\n * `heartbeat_fresh` refusal never reaches the store, `steal_refused_owner_alive`\n * is the liveness probe declining, and `claim_lost`/`activation_lost` are the\n * driver observing a lost store CAS.\n *\n * @category metrics\n * @since 0.1.0\n */\nexport const claims = Metric.counter(\"flows_engine_claims\", {\n  description: \"Run driver claim-and-activate decisions by outcome\"\n})\n\n/**\n * `claims` views keyed by driver decision.\n *\n * @category metrics\n * @since 0.1.0\n */\nexport const claim = byOutcome(\n  claims,\n  {},\n  [\"Activated\", \"Terminal\", \"HeartbeatFresh\", \"StealRefusedOwnerAlive\", \"ClaimLost\", \"ActivationLost\"] as const\n)\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/cjs/Errors.d.ts

@@ -0,0 +1,22 @@
+/**
+ * The public, stable error contract of `@smthrs/engine-store`.
+ *
+ * Every error here carries a `code` literal that is part of the public API:
+ * consumers may switch on `code` (or `_tag`) and the strings will not change
+ * without a major version. The classes themselves are declared next to the
+ * logic that raises them (`internal/ActionPersistence.ts`,
+ * `@smthrs/flow/Action`, and `@smthrs/flow/FlowRuntime`); this module is the
+ * barrel-exported surface so that `internal/` never has to be imported by
+ * consumers.
+ *
+ * Related documentation: `docs/troubleshooting.md` names every code and
+ * what to change; `docs/api.md` carries the schemas.
+ *
+ * @since 0.1.0
+ */
+export { IrreversibleRetryRequiresIdempotencyKey } from "@smthrs/flow/Action";
+export { FlowCycleDetected } from "@smthrs/flow/FlowRuntime";
+export { AttemptAdmissionRejected, AttemptEvidenceQuarantined, AttemptSuspended, CacheConflictDetected, CacheCorruptionDetected } from "./internal/ActionPersistence.ts";
+export { RetentionError, RetentionErrorCode } from "./internal/RetentionOps.ts";
+export { RunCatalogError, RunCatalogErrorCode } from "./internal/RunCatalogOps.ts";
+//# sourceMappingURL=Errors.d.ts.map

package/dist/cjs/Errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Errors.d.ts","sourceRoot":"","sources":["../../src/Errors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,uCAAuC,EAAE,MAAM,qBAAqB,CAAA;AAC7E,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAA;AAC5D,OAAO,EACL,wBAAwB,EACxB,0BAA0B,EAC1B,gBAAgB,EAChB,qBAAqB,EACrB,uBAAuB,EACxB,MAAM,iCAAiC,CAAA;AACxC,OAAO,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,4BAA4B,CAAA;AAC/E,OAAO,EAAE,eAAe,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAA"}

package/dist/cjs/Errors.js

@@ -0,0 +1,39 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var Errors_exports = {};
+__export(Errors_exports, {
+  AttemptAdmissionRejected: () => import_ActionPersistence.AttemptAdmissionRejected,
+  AttemptEvidenceQuarantined: () => import_ActionPersistence.AttemptEvidenceQuarantined,
+  AttemptSuspended: () => import_ActionPersistence.AttemptSuspended,
+  CacheConflictDetected: () => import_ActionPersistence.CacheConflictDetected,
+  CacheCorruptionDetected: () => import_ActionPersistence.CacheCorruptionDetected,
+  FlowCycleDetected: () => import_FlowRuntime.FlowCycleDetected,
+  IrreversibleRetryRequiresIdempotencyKey: () => import_Action.IrreversibleRetryRequiresIdempotencyKey,
+  RetentionError: () => import_RetentionOps.RetentionError,
+  RetentionErrorCode: () => import_RetentionOps.RetentionErrorCode,
+  RunCatalogError: () => import_RunCatalogOps.RunCatalogError,
+  RunCatalogErrorCode: () => import_RunCatalogOps.RunCatalogErrorCode
+});
+module.exports = __toCommonJS(Errors_exports);
+var import_Action = require("@smthrs/flow/Action");
+var import_FlowRuntime = require("@smthrs/flow/FlowRuntime");
+var import_ActionPersistence = require("./internal/ActionPersistence.js");
+var import_RetentionOps = require("./internal/RetentionOps.js");
+var import_RunCatalogOps = require("./internal/RunCatalogOps.js");
+//# sourceMappingURL=Errors.js.map

package/dist/cjs/Errors.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/Errors.ts"],
+  "sourcesContent": ["/**\n * The public, stable error contract of `@smthrs/engine-store`.\n *\n * Every error here carries a `code` literal that is part of the public API:\n * consumers may switch on `code` (or `_tag`) and the strings will not change\n * without a major version. The classes themselves are declared next to the\n * logic that raises them (`internal/ActionPersistence.ts`,\n * `@smthrs/flow/Action`, and `@smthrs/flow/FlowRuntime`); this module is the\n * barrel-exported surface so that `internal/` never has to be imported by\n * consumers.\n *\n * Related documentation: `docs/troubleshooting.md` names every code and\n * what to change; `docs/api.md` carries the schemas.\n *\n * @since 0.1.0\n */\n\nexport { IrreversibleRetryRequiresIdempotencyKey } from \"@smthrs/flow/Action\"\nexport { FlowCycleDetected } from \"@smthrs/flow/FlowRuntime\"\nexport {\n  AttemptAdmissionRejected,\n  AttemptEvidenceQuarantined,\n  AttemptSuspended,\n  CacheConflictDetected,\n  CacheCorruptionDetected\n} from \"./internal/ActionPersistence.ts\"\nexport { RetentionError, RetentionErrorCode } from \"./internal/RetentionOps.ts\"\nexport { RunCatalogError, RunCatalogErrorCode } from \"./internal/RunCatalogOps.ts\"\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAiBA,oBAAwD;AACxD,yBAAkC;AAClC,+BAMO;AACP,0BAAmD;AACnD,2BAAqD;",
+  "names": []
+}

package/dist/cjs/EventTypes.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Stable engine journal record names shared with replay consumers.
+ *
+ * @since 1.0.0
+ */
+/**
+ * Persisted event types and the child-spawn effect kind. Writers and readers
+ * share these identities; changing a value requires migrating stored history.
+ * `childSpawnKind` names the effect inside a boundary, not its event type.
+ *
+ * @since 1.0.0
+ * @category constants
+ */
+export declare const EventTypes: {
+    readonly runDecision: "flows.engine.run-decision";
+    readonly attemptStarted: "flows.engine.attempt-started";
+    readonly attemptFinished: "flows.engine.attempt-finished";
+    readonly snapshotIdentified: "flows.engine.snapshot-identified";
+    readonly planRecorded: "flows.engine.plan-recorded";
+    readonly subgraphAppended: "flows.engine.subgraph-appended";
+    readonly deferredCompleted: "flows.engine.deferred-completed";
+    readonly deferredConsumed: "flows.engine.deferred-consumed";
+    readonly clockScheduled: "flows.engine.clock-scheduled";
+    readonly clockCompleted: "flows.engine.clock-completed";
+    readonly childSpawnKind: "flows/engine-store/child-spawn";
+};
+//# sourceMappingURL=EventTypes.d.ts.map

package/dist/cjs/EventTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EventTypes.d.ts","sourceRoot":"","sources":["../../src/EventTypes.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;CAYb,CAAA"}

package/dist/cjs/EventTypes.js

@@ -0,0 +1,37 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var EventTypes_exports = {};
+__export(EventTypes_exports, {
+  EventTypes: () => EventTypes
+});
+module.exports = __toCommonJS(EventTypes_exports);
+const EventTypes = {
+  runDecision: "flows.engine.run-decision",
+  attemptStarted: "flows.engine.attempt-started",
+  attemptFinished: "flows.engine.attempt-finished",
+  snapshotIdentified: "flows.engine.snapshot-identified",
+  planRecorded: "flows.engine.plan-recorded",
+  subgraphAppended: "flows.engine.subgraph-appended",
+  deferredCompleted: "flows.engine.deferred-completed",
+  deferredConsumed: "flows.engine.deferred-consumed",
+  clockScheduled: "flows.engine.clock-scheduled",
+  clockCompleted: "flows.engine.clock-completed",
+  childSpawnKind: "flows/engine-store/child-spawn"
+};
+//# sourceMappingURL=EventTypes.js.map

package/dist/cjs/EventTypes.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/EventTypes.ts"],
+  "sourcesContent": ["/**\n * Stable engine journal record names shared with replay consumers.\n *\n * @since 1.0.0\n */\n\n/**\n * Persisted event types and the child-spawn effect kind. Writers and readers\n * share these identities; changing a value requires migrating stored history.\n * `childSpawnKind` names the effect inside a boundary, not its event type.\n *\n * @since 1.0.0\n * @category constants\n */\nexport const EventTypes = {\n  runDecision: \"flows.engine.run-decision\",\n  attemptStarted: \"flows.engine.attempt-started\",\n  attemptFinished: \"flows.engine.attempt-finished\",\n  snapshotIdentified: \"flows.engine.snapshot-identified\",\n  planRecorded: \"flows.engine.plan-recorded\",\n  subgraphAppended: \"flows.engine.subgraph-appended\",\n  deferredCompleted: \"flows.engine.deferred-completed\",\n  deferredConsumed: \"flows.engine.deferred-consumed\",\n  clockScheduled: \"flows.engine.clock-scheduled\",\n  clockCompleted: \"flows.engine.clock-completed\",\n  childSpawnKind: \"flows/engine-store/child-spawn\"\n} as const\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAcO,MAAM,aAAa;AAAA,EACxB,aAAa;AAAA,EACb,gBAAgB;AAAA,EAChB,iBAAiB;AAAA,EACjB,oBAAoB;AAAA,EACpB,cAAc;AAAA,EACd,kBAAkB;AAAA,EAClB,mBAAmB;AAAA,EACnB,kBAAkB;AAAA,EAClB,gBAAgB;AAAA,EAChB,gBAAgB;AAAA,EAChB,gBAAgB;AAClB;",
+  "names": []
+}