@systemfsoftware/trace-spec 1.0.1 → 1.2.4

package/CHANGELOG.md

@@ -1,123 +1,5 @@
 # @systemfsoftware/trace-spec
 
-## 1.0.1
+# @systemfsoftware/trace-spec@1.2.4
 
-### Patch Changes
-
-- Updated dependencies:
-  - @systemfsoftware/vitest@2.0.0
-
-## 1.0.0
-
-### Major Changes
-
-- Require `effect` `^4` (stable 4.0.0). Release candidates are no longer supported: imports follow 4.0.0's module layout (`effect/http`, `effect/rpc`, `effect/http-api`, `effect/cluster`, `effect/process`, `effect/socket`, `effect/persistence`, `effect/reactivity`, `effect/encoding`, `effect/Arbitrary`), which does not exist in any 4.0.0 RC.
-
-### Patch Changes
-
-- Updated dependencies:
-  - @systemfsoftware/effect-cell-types@12.0.0
-  - @systemfsoftware/effect-spec-runtime@1.0.0
-  - @systemfsoftware/trace-taxonomy@1.0.0
-  - @systemfsoftware/vitest@1.0.0
-
-## 0.5.2
-
-### Patch Changes
-
-- Updated dependencies:
-  - @systemfsoftware/vitest@0.3.0
-
-## 0.5.1
-
-### Patch Changes
-
-- Updated dependencies:
-  - @systemfsoftware/effect-cell-types@11.0.0
-
-## 0.5.0
-
-### Minor Changes
-
-- `Rel.Hold`, `Rel.Break` and `ObservationWindow.ObservationWindowSpec` are schema structs instead of classes, with unchanged encoded shapes: build them with `.make(...)` instead of `new`. The `VerdictTypeId` type is removed. `IncompleteObservationError.spanCount` must be a non-negative integer, and span `startMillis` and `durationMillis` must be finite and non-negative.
-
-- `Contract.check(expect, input, options?)` takes the test's `expect` and ends in one check: a break fails it with the report as the message. `Contract.judge` returns the `{ verdict: 'Hold' | 'Break', report }` value, and `Contract.verdictCheck(contract, expect, judgment)` turns one into a check. `TraceDisparityError` is removed. `Suite` cases register as generator tests and judge each case once.
-
-- The lawful test runner is now a peer dependency under its own name, `@systemfsoftware/vitest`, instead of the `@effect/vitest` alias that pointed at it. Install `@systemfsoftware/vitest` and import `it`, `layer`, `expect`, and the rest from `@systemfsoftware/vitest`. `@systemfsoftware/effect-gherkin-spec` re-exports `it` and `layer` from `@systemfsoftware/vitest`.
-
-- A broken contract now fails the check with `BreakFailure`, whose message is the break report, pointing at the line that called the check.
-
-- Cases now run on the simulation kernel — the zero-preemption schedule, then the profile's seeded schedules — instead of always on the live clock, and each case draws its own crypto-random salt, so two cases never share a trace id.
-
-  - `Suite.make({ it, layer })` → `Suite.make({ it })`.
-  - A case that must stay live declares a reason on any stage: `.live('...')`, or the new `Suite.live` combinator (`self.pipe(Suite.live(reason))`).
-  - `withLayer(shared)` rebuilds the shared layer freshly for every case rather than once per suite.
-  - `Stimulus.traceContext` draws its ids through Effect's `Random`, so a seeded run replays the same trace ids.
-
-### Patch Changes
-
-- Update peer and runtime dependency on `effect` and companion packages to `4.0.0-rc.117`.
-
-- Updated dependencies:
-  - @systemfsoftware/trace-taxonomy@0.0.2
-  - @systemfsoftware/vitest@0.2.0
-
-## 0.4.0
-
-### Minor Changes
-
-- `Contract.check(expect, input, options?)` takes the test's `expect` and ends in one check: a break fails it with the report as the message. `Contract.judge` returns the `{ verdict: 'Hold' | 'Break', report }` value, and `Contract.verdictCheck(contract, expect, judgment)` turns one into a check. `TraceDisparityError` is removed. `Suite` cases register as generator tests and judge each case once.
-
-### Patch Changes
-
-- Updated dependencies:
-  - @systemfsoftware/vitest@0.1.0
-
-## 0.3.0
-
-### Minor Changes
-
-- Requires `@systemfsoftware/vitest` installed under the `@effect/vitest` name (`"@effect/vitest": "npm:@systemfsoftware/vitest"`) in place of the upstream package. `Case.prop` checks the stimulus it is handed on every run and pins the run's input, so a stimulus that ignores its input fails; the trace dump path is annotated on the failing test.
-
-### Patch Changes
-
-- The observation window is built on the `Blueprint` and `Handle` kinds, with unchanged behaviour. The blueprint's `TypeId` is now exported as a value.
-
-- Updated dependencies:
-  - @systemfsoftware/effect-spec-runtime@0.2.0
-
-## 0.2.1
-
-### Patch Changes
-
-- Update peer and runtime dependency on `effect` and companion packages to `4.0.0-rc.117`.
-
-- Updated dependencies:
-  - @systemfsoftware/trace-taxonomy@0.0.1
-
-## 0.2.0
-
-### Minor Changes
-
-- Judge contracts against traces produced in another process. `RemoteObservation.layer(source, { interval, settle, timeout })` provides `Observation` by reading a trace store until no read has added a span for `settle`. `TempoTraceStore.source({ baseUrl })` reads Grafana Tempo's `/api/v2/traces/<traceId>` through the `HttpClient` you provide; put auth and tenant headers on that client.
-
-  New failures `Observation.IncompleteObservationError` (spans never settled, or the store marked the trace partial) and `Observation.TransportObservationError` (the store could not be read) join `Collector.collect`, `Contract.JudgeFailure`, and `Suite.CaseFailure`. This is a breaking type change: code that matches every case of these unions, or restates them by hand, must handle both.
-
-## 0.1.0
-
-### Minor Changes
-
-- `Rel`, `Graph`, `FailureDump` and `Prop` functions that took their subject first can now also be called data-last inside `pipe`. Existing calls keep working.
-
-### Patch Changes
-
-- Updated dependencies:
-  - @systemfsoftware/effect-spec-runtime@0.1.0
-
-## 0.0.0
-
-### Minor Changes
-
-- New package: hold a behaviour to the trace it produced. `Contract.of(taxonomy).stimulate(stimulus).holds(relation)` composes a spec; `Contract.judge(contract, input)` runs the behaviour under a trace id it mints, decodes the finished trace against the taxonomy, and answers the verdict with the dump path of a break; `Contract.check` fails a break with `Contract.TraceDisparityError`. `Graph.decode` is pure, answering `Result<TraceGraph, ContractDecodeError>`.
-
-  `ObservationWindow.make(serviceName)` is the in-memory observation resource: `.scoped` acquires a window handle read with `ObservationWindow.collect`, and `.layer` provides `Observation | OtelTracer.OtelTracer`, one window per acquisition. `Suite.make({ it, layer })` registers a `Case` per input or a `Case.prop` per Schema, shrinking through `it.effect.prop` to one dump of the minimal failing input.
+Published declaration files no longer carry the rolldown-plugin-dts patch; they come from rolldown-plugin-dts 0.28.8, which includes the same fix upstream.

package/dist/index.d.ts

@@ -2,18 +2,20 @@ import { Context, Duration, Effect, FileSystem, Layer, Option, Schema } from "ef
 import { Pipeable } from "effect/Pipeable";
 import { Span, Taxonomy } from "@systemfsoftware/trace-taxonomy";
 import * as Result$1 from "effect/Result";
-import * as HttpClient from "effect/http/HttpClient";
-import { Blueprint, Handle } from "@systemfsoftware/effect-cell-types";
 import * as OtelTracer from "@effect/opentelemetry/OtelTracer";
+import { Blueprint, Handle } from "@systemfsoftware/effect-cell-types";
 import { BasicTracerProvider, ReadableSpan } from "@opentelemetry/sdk-trace-base";
 import { Suite } from "@systemfsoftware/effect-spec-runtime";
+import * as HttpClient from "effect/http/HttpClient";
 import { Asserted, Check, Expect } from "@systemfsoftware/vitest";
 import * as Scope from "effect/Scope";
 import * as Arbitrary from "effect/Arbitrary";
 //#region src/BreakFailure.schema.d.ts
 declare const BreakFailure_base: Schema.Class<BreakFailure, Schema.TaggedStruct<"BreakFailure", {
   readonly report: Schema.String;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
 declare class BreakFailure extends BreakFailure_base {
   get message(): string;
 }
@@ -25,7 +27,9 @@ declare const ContractDecodeError_base: Schema.Class<ContractDecodeError, Schema
   readonly spanId: Schema.String;
   readonly attribute: Schema.String;
   readonly detail: Schema.String;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
 declare class ContractDecodeError extends ContractDecodeError_base {
   get message(): string;
 }
@@ -34,7 +38,9 @@ declare class ContractDecodeError extends ContractDecodeError_base {
 declare const EmptyObservationError_base: Schema.Class<EmptyObservationError, Schema.TaggedStruct<"EmptyObservationError", {
   readonly traceId: Schema.String;
   readonly detail: Schema.String;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
 declare class EmptyObservationError extends EmptyObservationError_base {
   get message(): string;
 }
@@ -44,7 +50,9 @@ declare const IncompleteObservationError_base: Schema.Class<IncompleteObservatio
   readonly traceId: Schema.String;
   readonly spanCount: Schema.Int;
   readonly detail: Schema.String;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
 declare class IncompleteObservationError extends IncompleteObservationError_base {
   get message(): string;
 }
@@ -160,7 +168,9 @@ declare const TransportObservationError_base: Schema.Class<TransportObservationE
   readonly traceId: Schema.String;
   readonly source: Schema.String;
   readonly detail: Schema.String;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
 declare class TransportObservationError extends TransportObservationError_base {
   get message(): string;
 }
@@ -256,7 +266,7 @@ declare const fromTaxonomy: {
   }): Relation;
 };
 declare namespace Stimulus_d_exports {
-  export { Run, Stimulus, TraceContext, make$3 as make, traceContext };
+  export { Run, Stimulus, TraceContext, make$2 as make, traceContext };
 }
 interface TraceContext {
   readonly traceId: string;
@@ -273,7 +283,7 @@ interface Stimulus<Input, Output, E, R> {
   readonly name: string;
   (input: Input): Effect.Effect<Run<Input, Output>, E, R>;
 }
-declare const make$3: <Input, Output, E, R>(options: {
+declare const make$2: <Input, Output, E, R>(options: {
   readonly name: string;
   readonly run: (context: {
     readonly input: Input;
@@ -354,55 +364,14 @@ declare const check: {
   <Input>(expect: Expect, input: Input, options?: CheckOptions): <Output, E, R>(self: Contract<Input, Output, E, R>) => Effect.Effect<void, JudgeFailure<E>, Asserted | Services<R>>;
   <Input, Output, E, R>(self: Contract<Input, Output, E, R>, expect: Expect, input: Input, options?: CheckOptions): Effect.Effect<void, JudgeFailure<E>, Asserted | Services<R>>;
 };
-declare namespace RemoteObservation_d_exports {
-  export { Options, TraceSource, layer$1 as layer };
-}
-/**
- * The cadence of the poll, the quiet window the observed span set must hold
- * before the read is trusted, and the deadline the whole poll runs under.
- * Durations are refused unless they are positive, at layer construction.
- */
-interface Options {
-  readonly interval: Duration.Input;
-  readonly settle: Duration.Input;
-  readonly timeout: Duration.Input;
-}
-/**
- * One read against one store: the spans that store currently holds for a trace
- * id, or the store's own transport or unfinished answer. A source never polls,
- * waits, or retries — the cadence belongs to {@link layer}.
- */
-type TraceSource<R> = (traceId: string) => Effect.Effect<ReadonlyArray<SpanRecord>, IncompleteObservationError | TransportObservationError, R>;
-/**
- * The `Observation` service over one trace source. `collect` reads the source at
- * `options.interval`, keeps every span it has seen keyed by span id, and answers
- * when that union has stayed unchanged for `options.settle`; a trace the store
- * never served is `EmptyObservationError`, one that never settled is
- * `IncompleteObservationError`, and the source's own failure ends the poll
- * immediately, unchanged. Provides `Observation` alone and requires exactly what
- * the source requires (`Scope.Scope` is supplied by the layer machinery, as
- * every Effect layer constructor scopes it away).
- */
-declare const layer$1: {
-  (options: Options): <R>(source: TraceSource<R>) => Layer.Layer<Observation, never, Exclude<R, Scope.Scope>>;
-  <R>(source: TraceSource<R>, options: Options): Layer.Layer<Observation, never, Exclude<R, Scope.Scope>>;
-};
-declare namespace tempo_trace_store_d_exports {
-  export { source };
-}
-/** One read against one Tempo endpoint. Its only requirement is the caller's HTTP client. */
-declare const source: (options: {
-  readonly baseUrl: string;
-}) => TraceSource<HttpClient.HttpClient>;
 //#endregion
 //#region src/ObservationWindowSpec.schema.d.ts
 declare const ObservationWindowSpec: Schema.Struct<{
   readonly serviceName: Schema.NonEmptyString;
 }>;
 type ObservationWindowSpec = typeof ObservationWindowSpec.Type;
-declare namespace observation_window_handle_d_exports {
-  export { ObservationWindow, TypeId$2 as TypeId, collect, context, isObservationWindow, make$2 as make, shutdown };
-}
+//#endregion
+//#region src/observation-window.handle.d.ts
 declare const TypeId$2: unique symbol;
 type TypeId$2 = typeof TypeId$2;
 /**
@@ -424,32 +393,62 @@ declare const isObservationWindow: (u: unknown) => u is Handle.Handle<typeof Typ
   readonly store: SpanRecordStore;
   readonly provider: BasicTracerProvider;
 }, never>;
-declare const make$2: (spec: ObservationWindowSpec) => ObservationWindow;
-declare const shutdown: (self: ObservationWindow) => Effect.Effect<void>;
 declare const collect: {
   (traceId: string): (self: ObservationWindow) => Effect.Effect<ReadonlyArray<SpanRecord>, EmptyObservationError>;
   (self: ObservationWindow, traceId: string): Effect.Effect<ReadonlyArray<SpanRecord>, EmptyObservationError>;
 };
-declare const context: (self: ObservationWindow) => Context.Context<Observation | OtelTracer.OtelTracerProvider>;
 declare namespace observation_window_blueprint_d_exports {
   export { ObservationWindow, ObservationWindowBlueprint, ObservationWindowSpec, TypeId$2 as ObservationWindowTypeId, TypeId$1 as TypeId, collect, isObservationWindow, make$1 as make };
 }
 declare const TypeId$1: unique symbol;
 type TypeId$1 = typeof TypeId$1;
 declare const scoped: (spec: ObservationWindowSpec) => Effect.Effect<ObservationWindow, never, Scope.Scope>;
-declare const layer: (spec: ObservationWindowSpec) => Layer.Layer<Observation | OtelTracer.OtelTracer>;
+declare const layer$1: (spec: ObservationWindowSpec) => Layer.Layer<Observation | OtelTracer.OtelTracer>;
 declare const ObservationWindows: Blueprint.Definition<typeof TypeId$1, {
   readonly serviceName: string;
 }, Blueprint.Derived<{
   readonly serviceName: string;
 }, {}, {
   readonly scoped: typeof scoped;
-  readonly layer: typeof layer;
+  readonly layer: typeof layer$1;
 }>, {
   readonly serviceName: string;
 }>;
 type ObservationWindowBlueprint = Blueprint.Of<typeof ObservationWindows>;
 declare const make$1: (serviceName: string) => ObservationWindowBlueprint;
+declare namespace RemoteObservation_d_exports {
+  export { Options, TraceSource, layer };
+}
+/**
+ * The cadence of the poll, the quiet window the observed span set must hold
+ * before the read is trusted, and the deadline the whole poll runs under.
+ * Durations are refused unless they are positive, at layer construction.
+ */
+interface Options {
+  readonly interval: Duration.Input;
+  readonly settle: Duration.Input;
+  readonly timeout: Duration.Input;
+}
+/**
+ * One read against one store: the spans that store currently holds for a trace
+ * id, or the store's own transport or unfinished answer. A source never polls,
+ * waits, or retries — the cadence belongs to {@link layer}.
+ */
+type TraceSource<R> = (traceId: string) => Effect.Effect<ReadonlyArray<SpanRecord>, IncompleteObservationError | TransportObservationError, R>;
+/**
+ * The `Observation` service over one trace source. `collect` reads the source at
+ * `options.interval`, keeps every span it has seen keyed by span id, and answers
+ * when that union has stayed unchanged for `options.settle`; a trace the store
+ * never served is `EmptyObservationError`, one that never settled is
+ * `IncompleteObservationError`, and the source's own failure ends the poll
+ * immediately, unchanged. Provides `Observation` alone and requires exactly what
+ * the source requires (`Scope.Scope` is supplied by the layer machinery, as
+ * every Effect layer constructor scopes it away).
+ */
+declare const layer: {
+  (options: Options): <R>(source: TraceSource<R>) => Layer.Layer<Observation, never, Exclude<R, Scope.Scope>>;
+  <R>(source: TraceSource<R>, options: Options): Layer.Layer<Observation, never, Exclude<R, Scope.Scope>>;
+};
 //#endregion
 //#region src/HarnessFailure.schema.d.ts
 declare const HarnessFailure: Schema.Union<readonly [typeof ContractDecodeError, typeof EmptyObservationError, typeof IncompleteObservationError, typeof TransportObservationError]>;
@@ -459,7 +458,9 @@ type HarnessFailure = typeof HarnessFailure.Type;
 declare const StimulusFailure_base: Schema.Class<StimulusFailure, Schema.TaggedStruct<"StimulusFailure", {
   readonly stimulus: Schema.String;
   readonly detail: Schema.String;
-}>, import("effect/Cause").YieldableError>;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
 declare class StimulusFailure extends StimulusFailure_base {
   get message(): string;
 }
@@ -518,5 +519,12 @@ declare const live: {
   <Self>(self: LiveStage<Self>, reason: string): Self;
 };
 declare const make: (bindings: Suite.Bindings) => (name: string) => Declared;
+declare namespace tempo_trace_store_d_exports {
+  export { source };
+}
+/** One read against one Tempo endpoint. Its only requirement is the caller's HTTP client. */
+declare const source: (options: {
+  readonly baseUrl: string;
+}) => TraceSource<HttpClient.HttpClient>;
 //#endregion
 export { Contract_d_exports as Contract, Graph_d_exports as Graph, Observation_service_d_exports as Observation, observation_window_blueprint_d_exports as ObservationWindow, Rel_d_exports as Rel, RemoteObservation_d_exports as RemoteObservation, Stimulus_d_exports as Stimulus, Suite_d_exports as Suite, tempo_trace_store_d_exports as TempoTraceStore };

package/dist/index.mjs

@@ -7,16 +7,16 @@ import "effect/PlatformError";
 import "@systemfsoftware/trace-taxonomy";
 import "effect/Array";
 import * as Result$1 from "effect/Result";
-import * as HttpClient from "effect/http/HttpClient";
-import * as HttpClientRequest from "effect/http/HttpClientRequest";
-import * as HttpClientResponse from "effect/http/HttpClientResponse";
-import { Blueprint, Handle, Workflow } from "@systemfsoftware/effect-cell-types";
-import { Hex } from "effect/encoding";
 import * as OtelTracer from "@effect/opentelemetry/OtelTracer";
 import * as OtelResource from "@effect/opentelemetry/Resource";
+import { Blueprint, Handle, Workflow } from "@systemfsoftware/effect-cell-types";
 import { SpanStatusCode } from "@opentelemetry/api";
 import { AlwaysOnSampler, BasicTracerProvider } from "@opentelemetry/sdk-trace-base";
 import { Suite, TaskRef } from "@systemfsoftware/effect-spec-runtime";
+import * as HttpClient from "effect/http/HttpClient";
+import * as HttpClientRequest from "effect/http/HttpClientRequest";
+import * as HttpClientResponse from "effect/http/HttpClientResponse";
+import { Hex } from "effect/encoding";
 //#region src/BreakFailure.schema.ts
 var BreakFailure = class extends Schema.TaggedError()("BreakFailure", { report: Schema.String }) {
 	get message() {
@@ -367,258 +367,6 @@ const checkDual = (self, expect, input, options) => {
 */
 const check = dual((args) => isContract(args[0]), checkDual);
 //#endregion
-//#region src/drivers/judge-tempo-answer.workflow.ts
-const JudgeTempoAnswerTypeId = Symbol.for("@systemfsoftware/trace-spec/JudgeTempoAnswer");
-var TempoBodyDecoded = class extends Schema.TaggedClass()("TempoBodyDecoded", {
-	spans: Schema.Array(SpanRecord),
-	status: Schema.optional(Schema.String)
-}) {};
-var TempoBodyUndecodable = class extends Schema.TaggedClass()("TempoBodyUndecodable", { detail: Schema.String }) {};
-const TempoBody = Schema.Union([TempoBodyDecoded, TempoBodyUndecodable]);
-var TempoAnswerComplete = class extends Schema.TaggedClass()("TempoAnswerComplete", { spans: Schema.Array(SpanRecord) }) {
-	[JudgeTempoAnswerTypeId] = JudgeTempoAnswerTypeId;
-};
-var TempoAnswerIncomplete = class extends Schema.TaggedClass()("TempoAnswerIncomplete", {
-	status: Schema.String,
-	spanCount: Schema.Int
-}) {
-	[JudgeTempoAnswerTypeId] = JudgeTempoAnswerTypeId;
-};
-var TempoAnswerUndecodable = class extends Schema.TaggedClass()("TempoAnswerUndecodable", { detail: Schema.String }) {
-	[JudgeTempoAnswerTypeId] = JudgeTempoAnswerTypeId;
-};
-const TempoAnswerDecision = Schema.Union([
-	TempoAnswerComplete,
-	TempoAnswerIncomplete,
-	TempoAnswerUndecodable
-]);
-var JudgeTempoAnswer = class extends Schema.TaggedClass()("JudgeTempoAnswer", { body: TempoBody }) {
-	static [Workflow.InstrumentationBrand] = {};
-};
-const isComplete = (status) => Option.match(status, {
-	onNone: () => true,
-	onSome: (marked) => marked === "COMPLETE"
-});
-const classify$1 = (spans, status) => Match.value(isComplete(status)).pipe(Match.when(true, () => new TempoAnswerComplete({ spans })), Match.when(false, () => new TempoAnswerIncomplete({
-	status: Option.getOrElse(status, () => "INCOMPLETE"),
-	spanCount: spans.length
-})), Match.exhaustive);
-const decide$5 = (command) => Result$1.succeed(Match.value(command.body).pipe(Match.tag("TempoBodyDecoded", (decoded) => classify$1(decoded.spans, Option.fromUndefinedOr(decoded.status))), Match.tag("TempoBodyUndecodable", (undecodable) => new TempoAnswerUndecodable({ detail: undecodable.detail })), Match.exhaustive));
-const judgeTempoAnswer = Workflow.make({
-	command: JudgeTempoAnswer,
-	decision: TempoAnswerDecision,
-	error: Schema.Never,
-	decide: decide$5
-});
-//#endregion
-//#region src/drivers/tempo-trace.schema.ts
-/** Proto bytes (base64 on the wire) as the lowercase hex ids traces are addressed by. */
-const HexId = Schema.Uint8ArrayFromBase64.pipe(Schema.decodeTo(Schema.String, {
-	decode: SchemaGetter.transform(Hex.encode),
-	encode: SchemaGetter.decodeHex()
-}));
-const secondsAndNanos = (nanos) => {
-	const text = nanos.padStart(10, "0");
-	return [Number(text.slice(0, -9)), Number(text.slice(-9))];
-};
-const millisOf$2 = (nanos) => {
-	const [seconds, subMillis] = secondsAndNanos(nanos);
-	return seconds * 1e3 + subMillis / 1e6;
-};
-const MillisFromNanos = Schema.String.pipe(Schema.decodeTo(Schema.Finite, SchemaTransformation.transform({
-	decode: millisOf$2,
-	encode: (millis) => String(Math.round(millis * 1e6))
-})));
-const unsetParent = (parent) => parent === "" || /^0+$/.test(parent);
-const heldParent = (parent) => unsetParent(parent) ? null : parent;
-const parentOf$1 = (parent) => heldParent(parent ?? "");
-const EMPTY_STATUS = {};
-const codeOf = (status) => status.code ?? "STATUS_CODE_UNSET";
-const STATUS_BY_CODE$1 = {
-	STATUS_CODE_UNSET: "unset",
-	STATUS_CODE_OK: "ok",
-	STATUS_CODE_ERROR: "error"
-};
-const statusOf$1 = (status) => STATUS_BY_CODE$1[codeOf(status ?? EMPTY_STATUS)];
-const stringValueOf = (value) => value.stringValue ?? null;
-const numberOf = (value) => value.doubleValue ?? intToNumber(value.intValue);
-const intToNumber = (text) => text === void 0 ? null : Number(text);
-const boolOrNumberOf = (value) => value.boolValue ?? numberOf(value);
-const scalarOf = (value) => stringValueOf(value) ?? boolOrNumberOf(value);
-const isScalarMember = (member) => member !== null;
-const arrayValuesOf = (value) => value.arrayValue?.values;
-const scalarMembersOf = (values) => values.map(scalarOf).filter(isScalarMember);
-const arrayValueOf = (values) => values === void 0 ? null : scalarMembersOf(values);
-const presentValueOf = (value) => scalarOf(value) ?? arrayValueOf(arrayValuesOf(value));
-const isPresent$1 = (entry) => entry[1] !== null;
-const entryOf = (attribute) => [attribute.key, attributeValueOf(attribute.value)];
-const attributeValueOf = (value) => value === void 0 ? null : presentValueOf(value);
-const attributesOf = (attributes) => Object.fromEntries((attributes ?? []).map(entryOf).filter(isPresent$1));
-const errorTypeOf$1 = (attributes) => {
-	const value = attributes["error.type"];
-	return typeof value === "string" ? value : null;
-};
-const eventOf = (event) => ({
-	name: event.name,
-	attributes: attributesOf(event.attributes)
-});
-const linkIdOf = (id) => id ?? "";
-const linkOf = (link) => ({
-	traceId: linkIdOf(link.traceId),
-	spanId: linkIdOf(link.spanId)
-});
-const eventsOf$1 = (span) => (span.events ?? []).map(eventOf);
-const linksOf$1 = (span) => (span.links ?? []).map(linkOf);
-const spanRecordOf$1 = (span) => {
-	const attributes = attributesOf(span.attributes);
-	return {
-		traceId: span.traceId,
-		spanId: span.spanId,
-		parentSpanId: parentOf$1(span.parentSpanId),
-		name: span.name,
-		status: statusOf$1(span.status),
-		errorType: errorTypeOf$1(attributes),
-		startMillis: span.startTimeUnixNano,
-		durationMillis: span.endTimeUnixNano - span.startTimeUnixNano,
-		attributes,
-		events: eventsOf$1(span),
-		links: linksOf$1(span)
-	};
-};
-const wireTextOf = (value) => typeof value === "string" ? { stringValue: value } : void 0;
-const wireBoolOf = (value) => typeof value === "boolean" ? { boolValue: value } : void 0;
-const isValueArray = (value) => Array.isArray(value);
-const wireArrayOf = (value) => ({ arrayValue: { values: isValueArray(value) ? value.map(wireValueOf) : [] } });
-const wireNumberOrArrayOf = (value) => typeof value === "number" ? { doubleValue: value } : wireArrayOf(value);
-const wireBoolOrNumberOf = (value) => wireBoolOf(value) ?? wireNumberOrArrayOf(value);
-const wireValueOf = (value) => wireTextOf(value) ?? wireBoolOrNumberOf(value);
-const wireAttributesOf = (attributes) => Object.entries(attributes).map(([key, value]) => ({
-	key,
-	value: wireValueOf(value)
-}));
-const STATUS_CODE_BY_STATUS = {
-	unset: "STATUS_CODE_UNSET",
-	ok: "STATUS_CODE_OK",
-	error: "STATUS_CODE_ERROR"
-};
-const wireStatusOf = (status) => ({ code: STATUS_CODE_BY_STATUS[status] });
-const wireSpanOf = (record) => ({
-	traceId: record.traceId,
-	spanId: record.spanId,
-	parentSpanId: record.parentSpanId ?? void 0,
-	name: record.name,
-	startTimeUnixNano: record.startMillis,
-	endTimeUnixNano: record.startMillis + record.durationMillis,
-	attributes: wireAttributesOf(record.attributes),
-	events: record.events.map((event) => ({
-		name: event.name,
-		attributes: wireAttributesOf(event.attributes)
-	})),
-	links: record.links.map((link) => ({
-		traceId: link.traceId,
-		spanId: link.spanId
-	})),
-	status: wireStatusOf(record.status)
-});
-const WireAnyValue = Schema.Struct({
-	stringValue: Schema.optional(Schema.String),
-	boolValue: Schema.optional(Schema.Boolean),
-	intValue: Schema.optional(Schema.String),
-	doubleValue: Schema.optional(Schema.Finite),
-	arrayValue: Schema.optional(Schema.Struct({ values: Schema.optional(Schema.Array(Schema.suspend(() => WireAnyValue))) }))
-});
-const WireAttribute = Schema.Struct({
-	key: Schema.String,
-	value: Schema.optional(WireAnyValue)
-});
-const WireStatus = Schema.Struct({
-	message: Schema.optional(Schema.String),
-	code: Schema.optional(Schema.Literals([
-		"STATUS_CODE_UNSET",
-		"STATUS_CODE_OK",
-		"STATUS_CODE_ERROR"
-	]))
-});
-const WireEvent = Schema.Struct({
-	name: Schema.String,
-	timeUnixNano: Schema.optional(MillisFromNanos),
-	attributes: Schema.optional(Schema.Array(WireAttribute))
-});
-const WireLink = Schema.Struct({
-	traceId: Schema.optional(HexId),
-	spanId: Schema.optional(HexId)
-});
-const WireSpan = Schema.Struct({
-	traceId: HexId,
-	spanId: HexId,
-	parentSpanId: Schema.optional(HexId),
-	name: Schema.String,
-	kind: Schema.optional(Schema.String),
-	startTimeUnixNano: MillisFromNanos,
-	endTimeUnixNano: MillisFromNanos,
-	attributes: Schema.optional(Schema.Array(WireAttribute)),
-	events: Schema.optional(Schema.Array(WireEvent)),
-	links: Schema.optional(Schema.Array(WireLink)),
-	status: Schema.optional(WireStatus),
-	traceState: Schema.optional(Schema.String),
-	flags: Schema.optional(Schema.Finite)
-}).pipe(Schema.decodeTo(SpanRecord, SchemaTransformation.transform({
-	decode: spanRecordOf$1,
-	encode: wireSpanOf
-})));
-const WireScopeSpans = Schema.Struct({ spans: Schema.optional(Schema.Array(WireSpan)) });
-const WireResourceSpans = Schema.Struct({ scopeSpans: Schema.optional(Schema.Array(WireScopeSpans)) });
-/** One trace-by-id answer: the spans, plus the store's completeness status when it is not complete. */
-const TempoV2TraceResponse = Schema.Struct({
-	trace: Schema.Struct({ resourceSpans: Schema.optional(Schema.Array(WireResourceSpans)) }),
-	status: Schema.optional(Schema.String),
-	message: Schema.optional(Schema.String)
-});
-//#endregion
-//#region src/drivers/tempo-trace-store.ts
-var tempo_trace_store_exports = /* @__PURE__ */ __exportAll({ source: () => source });
-/**
-* The Grafana Tempo trace source: one read of one trace by id against one
-* store endpoint. It never polls, waits, or retries — completeness belongs
-* to the remote observation layer. Any refusal (unreachable endpoint,
-* non-2xx answer, undecodable body) fails with the transport failure whose
-* `source` is the request URL; an answer the store marked incomplete fails
-* with the incomplete failure, since waiting cannot complete it.
-*/
-const parseBody = Schema.decodeResult(Schema.fromJsonString(TempoV2TraceResponse));
-const orEmpty = (values) => values ?? [];
-const spansOf = (response) => orEmpty(response.trace.resourceSpans).flatMap((resourceSpans) => orEmpty(resourceSpans.scopeSpans).flatMap((scopeSpans) => orEmpty(scopeSpans.spans)));
-const bodyOf = (decoded) => Result.match(decoded, {
-	onFailure: (error) => new TempoBodyUndecodable({ detail: error.message }),
-	onSuccess: (response) => new TempoBodyDecoded({
-		spans: spansOf(response),
-		status: response.status
-	})
-});
-const transportFailureOf = (traceId, url, cause) => new TransportObservationError({
-	traceId,
-	source: url,
-	detail: cause
-});
-const refusedOf = (traceId, url, error) => transportFailureOf(traceId, url, error.message);
-const undecodableOf = (traceId, url, detail) => transportFailureOf(traceId, url, `undecodable trace body: ${detail}`);
-const incompleteOf = (traceId, status, spanCount) => new IncompleteObservationError({
-	traceId,
-	spanCount,
-	detail: `the store answered ${status}: waiting cannot complete the trace`
-});
-const readTrace = (traceId, url, body) => Effect.flatMap(Effect.fromResult(judgeTempoAnswer(new JudgeTempoAnswer({ body: bodyOf(parseBody(body)) }))), (decision) => Match.value(decision).pipe(Match.tag("TempoAnswerComplete", (complete) => Effect.succeed(complete.spans)), Match.tag("TempoAnswerIncomplete", (incomplete) => Effect.fail(incompleteOf(traceId, incomplete.status, incomplete.spanCount))), Match.tag("TempoAnswerUndecodable", (undecodable) => Effect.fail(undecodableOf(traceId, url, undecodable.detail))), Match.exhaustive));
-/** One read against one Tempo endpoint. Its only requirement is the caller's HTTP client. */
-const source = (options) => {
-	const urlOf = (traceId) => `${options.baseUrl}/api/v2/traces/${traceId}`;
-	return (traceId) => {
-		const url = urlOf(traceId);
-		return HttpClient.execute(HttpClientRequest.get(url).pipe(HttpClientRequest.acceptJson)).pipe(Effect.flatMap(HttpClientResponse.filterStatusOk), Effect.flatMap((response) => response.text), Effect.mapError((error) => refusedOf(traceId, url, error)), Effect.flatMap((body) => readTrace(traceId, url, body)));
-	};
-};
-Schema.decodeEffect(HexId);
-Schema.encodeEffect(HexId);
-//#endregion
 //#region src/observation-window.handle.ts
 const TypeId$2 = Symbol.for("~systemfsoftware/trace-spec/ObservationWindow");
 const ObservationWindow = Handle.make()(TypeId$2);
@@ -669,52 +417,52 @@ const isScalar = (value) => SCALAR_TYPES[typeof value] === true;
 const scalarArrayOrNull = (value) => Array.isArray(value) ? value.filter(isScalar) : null;
 const definedOrEmpty = (value) => value ?? [];
 const attributeValue = (value) => isScalar(value) ? value : scalarArrayOrNull(definedOrEmpty(value));
-const isPresent = (entry) => entry[1] !== null;
-const attributeRecordOf = (attributes) => Object.fromEntries(Object.entries(attributes).map((entry) => [entry[0], attributeValue(entry[1])]).filter(isPresent));
-const STATUS_BY_CODE = {
+const isPresent$1 = (entry) => entry[1] !== null;
+const attributeRecordOf = (attributes) => Object.fromEntries(Object.entries(attributes).map((entry) => [entry[0], attributeValue(entry[1])]).filter(isPresent$1));
+const STATUS_BY_CODE$1 = {
 	[SpanStatusCode.OK]: "ok",
 	[SpanStatusCode.ERROR]: "error",
 	[SpanStatusCode.UNSET]: "unset"
 };
-const statusOf = (code) => STATUS_BY_CODE[code] ?? "unset";
-const errorTypeOf = (attributes) => {
+const statusOf$1 = (code) => STATUS_BY_CODE$1[code] ?? "unset";
+const errorTypeOf$1 = (attributes) => {
 	const value = attributes["error.type"];
 	return typeof value === "string" ? value : null;
 };
-const parentOf = (span) => {
+const parentOf$1 = (span) => {
 	const parent = span.parentSpanContext;
 	return parent === void 0 ? null : parent.spanId;
 };
-const eventsOf = (span) => span.events.map((event) => ({
+const eventsOf$1 = (span) => span.events.map((event) => ({
 	name: event.name,
 	attributes: attributeRecordOf(event.attributes ?? {})
 }));
-const linksOf = (span) => span.links.map((link) => ({
+const linksOf$1 = (span) => span.links.map((link) => ({
 	traceId: link.context.traceId,
 	spanId: link.context.spanId
 }));
-const millisOf$1 = (duration) => duration[0] * 1e3 + duration[1] / 1e6;
-const spanRecordOf = (span) => {
+const millisOf$2 = (duration) => duration[0] * 1e3 + duration[1] / 1e6;
+const spanRecordOf$1 = (span) => {
 	const attributes = attributeRecordOf(span.attributes);
 	return {
 		traceId: span.spanContext().traceId,
 		spanId: span.spanContext().spanId,
-		parentSpanId: parentOf(span),
+		parentSpanId: parentOf$1(span),
 		name: span.name,
-		status: statusOf(span.status.code),
-		errorType: errorTypeOf(attributes),
-		startMillis: millisOf$1(span.startTime),
-		durationMillis: millisOf$1(span.duration),
+		status: statusOf$1(span.status.code),
+		errorType: errorTypeOf$1(attributes),
+		startMillis: millisOf$2(span.startTime),
+		durationMillis: millisOf$2(span.duration),
 		attributes,
-		events: eventsOf(span),
-		links: linksOf(span)
+		events: eventsOf$1(span),
+		links: linksOf$1(span)
 	};
 };
 const emptyObservation = (traceId) => new EmptyObservationError({
 	traceId,
 	detail: "the observation window closed with no span carrying the stimulated trace id"
 });
-const recordsOf = (self, traceId) => ObservationWindow.slot(self).store.getFinishedSpans().filter((span) => span.spanContext().traceId === traceId).map(spanRecordOf);
+const recordsOf = (self, traceId) => ObservationWindow.slot(self).store.getFinishedSpans().filter((span) => span.spanContext().traceId === traceId).map(spanRecordOf$1);
 const collect = dual(2, (self, traceId) => Effect.suspend(() => {
 	const records = recordsOf(self, traceId);
 	return records.length > 0 ? Effect.succeed(records) : Effect.fail(emptyObservation(traceId));
@@ -772,7 +520,7 @@ var CombineAnyRelations = class extends Schema.TaggedClass()("CombineAnyRelation
 const holds = (verdict) => Match.value(verdict).pipe(Match.tag("Hold", () => true), Match.tag("Break", () => false), Match.exhaustive);
 const inspectedOf$1 = (verdicts) => Array$1.flatMap(verdicts, (verdict) => verdict.inspected);
 const namedConjuncts = (verdicts) => Array$1.join(Array$1.map(verdicts, (verdict) => verdict.conjunct), ", ");
-const decide$4 = (command) => Result$1.succeed(Match.value(Array$1.some(command.verdicts, holds)).pipe(Match.when(true, () => new AnyRelationHeld({
+const decide$5 = (command) => Result$1.succeed(Match.value(Array$1.some(command.verdicts, holds)).pipe(Match.when(true, () => new AnyRelationHeld({
 	conjunct: command.conjunct,
 	inspected: inspectedOf$1(command.verdicts)
 })), Match.when(false, () => new NoRelationHeld({
@@ -785,7 +533,7 @@ const combineAnyRelations = Workflow.make({
 	command: CombineAnyRelations,
 	decision: CombineAnyRelationsDecision,
 	error: Schema.Never,
-	decide: decide$4
+	decide: decide$5
 });
 //#endregion
 //#region src/combine-relation-verdicts.workflow.ts
@@ -846,7 +594,7 @@ const aggregateSoft = (command) => {
 		})
 	});
 };
-const decide$3 = (command) => Result$1.succeed(Option.match(firstHardBreak(command.verdicts), {
+const decide$4 = (command) => Result$1.succeed(Option.match(firstHardBreak(command.verdicts), {
 	onNone: () => aggregateSoft(command),
 	onSome: (winner) => new FirstHardBreak({
 		conjunct: winner.conjunct,
@@ -858,7 +606,7 @@ const combineRelationVerdicts = Workflow.make({
 	command: CombineRelationVerdicts,
 	decision: CombineRelationVerdictsDecision,
 	error: Schema.Never,
-	decide: decide$3
+	decide: decide$4
 });
 //#endregion
 //#region src/judge-edge-placement.workflow.ts
@@ -886,7 +634,7 @@ var JudgeEdgePlacement = class extends Schema.TaggedClass()("JudgeEdgePlacement"
 	static [Workflow.InstrumentationBrand] = {};
 };
 const everyPlaced = (placed, reached) => Array$1.every(placed, (spanId) => Array$1.some(reached, (candidate) => candidate === spanId));
-const decide$2 = (command) => Result$1.succeed(Match.value(everyPlaced(command.placed, command.reached)).pipe(Match.when(true, () => new EdgePlacementHeld({
+const decide$3 = (command) => Result$1.succeed(Match.value(everyPlaced(command.placed, command.reached)).pipe(Match.when(true, () => new EdgePlacementHeld({
 	conjunct: command.conjunct,
 	inspected: command.placed
 })), Match.when(false, () => new EdgePlacementBroken({
@@ -898,7 +646,7 @@ const judgeEdgePlacement = Workflow.make({
 	command: JudgeEdgePlacement,
 	decision: JudgeEdgePlacementDecision,
 	error: Schema.Never,
-	decide: decide$2
+	decide: decide$3
 });
 //#endregion
 //#region src/negate-relation-verdict.workflow.ts
@@ -923,7 +671,7 @@ var NegateRelationVerdict = class extends Schema.TaggedClass()("NegateRelationVe
 }) {
 	static [Workflow.InstrumentationBrand] = {};
 };
-const decide$1 = (command) => Result$1.succeed(Match.value(command.verdict).pipe(Match.tag("Hold", (held) => new HoldNegated({
+const decide$2 = (command) => Result$1.succeed(Match.value(command.verdict).pipe(Match.tag("Hold", (held) => new HoldNegated({
 	conjunct: command.conjunct,
 	inspected: held.inspected,
 	detail: `${held.conjunct} held`
@@ -935,7 +683,7 @@ const negateRelationVerdict = Workflow.make({
 	command: NegateRelationVerdict,
 	decision: NegateRelationVerdictDecision,
 	error: Schema.Never,
-	decide: decide$1
+	decide: decide$2
 });
 //#endregion
 //#region src/Rel.ts
@@ -1276,13 +1024,13 @@ const absorbed = (observed, read, elapsedMillis) => {
 	});
 };
 const quietForLongEnough = (observed, elapsedMillis, settleMillis) => Array$1.every([observed.spans.length > 0, elapsedMillis - observed.addedAtMillis >= settleMillis], Boolean);
-const classify = (observation, elapsedMillis, settleMillis, timeoutMillis) => Match.value(quietForLongEnough(observation, elapsedMillis, settleMillis)).pipe(Match.when(true, () => new ReadSettled({ observation })), Match.when(false, () => Match.value(elapsedMillis >= timeoutMillis).pipe(Match.when(true, () => Match.value(observation.spans.length === 0).pipe(Match.when(true, () => new ReadAbsent({ observation })), Match.when(false, () => new ReadUnfinished({ observation })), Match.exhaustive)), Match.when(false, () => new ReadStillGrowing({ observation })), Match.exhaustive)), Match.exhaustive);
-const decide = (command) => Result$1.succeed(classify(absorbed(command.observed, command.read, command.elapsedMillis), command.elapsedMillis, command.settleMillis, command.timeoutMillis));
+const classify$1 = (observation, elapsedMillis, settleMillis, timeoutMillis) => Match.value(quietForLongEnough(observation, elapsedMillis, settleMillis)).pipe(Match.when(true, () => new ReadSettled({ observation })), Match.when(false, () => Match.value(elapsedMillis >= timeoutMillis).pipe(Match.when(true, () => Match.value(observation.spans.length === 0).pipe(Match.when(true, () => new ReadAbsent({ observation })), Match.when(false, () => new ReadUnfinished({ observation })), Match.exhaustive)), Match.when(false, () => new ReadStillGrowing({ observation })), Match.exhaustive)), Match.exhaustive);
+const decide$1 = (command) => Result$1.succeed(classify$1(absorbed(command.observed, command.read, command.elapsedMillis), command.elapsedMillis, command.settleMillis, command.timeoutMillis));
 const settleRemoteRead = Workflow.make({
 	command: SettleRemoteRead,
 	decision: SettleRemoteReadDecision,
 	error: Schema.Never,
-	decide
+	decide: decide$1
 });
 //#endregion
 //#region src/RemoteObservation.ts
@@ -1314,17 +1062,17 @@ const settleStep = (settlement, read, elapsedMillis, windows) => {
 };
 const lateRefusal = (settlement) => settlement.spans.length === 0 ? "absent" : "unfinished";
 const deadlineVerdict = (settlement, elapsedMillis, windows) => pastDeadline(elapsedMillis, windows) ? refusedVerdict(lateRefusal(settlement)) : Option.none();
-const millisOf = (input) => Duration.toMillis(input);
+const millisOf$1 = (input) => Duration.toMillis(input);
 const windowsOf = (options) => ({
-	settleMillis: millisOf(options.settle),
-	timeoutMillis: millisOf(options.timeout)
+	settleMillis: millisOf$1(options.settle),
+	timeoutMillis: millisOf$1(options.timeout)
 });
 const nonPositive = (options) => [
 	options.interval,
 	options.settle,
 	options.timeout
-].some((input) => millisOf(input) <= 0);
-const requirePositive = (options) => nonPositive(options) ? Effect.die(/* @__PURE__ */ new Error(`remote observation durations must be positive milliseconds: interval=${millisOf(options.interval)}, settle=${millisOf(options.settle)}, timeout=${millisOf(options.timeout)}`)) : Effect.void;
+].some((input) => millisOf$1(input) <= 0);
+const requirePositive = (options) => nonPositive(options) ? Effect.die(/* @__PURE__ */ new Error(`remote observation durations must be positive milliseconds: interval=${millisOf$1(options.interval)}, settle=${millisOf$1(options.settle)}, timeout=${millisOf$1(options.timeout)}`)) : Effect.void;
 const absence = (traceId, windows) => new EmptyObservationError({
 	traceId,
 	detail: `the remote trace store served no span for trace ${traceId} before the ${windows.timeoutMillis}ms timeout`
@@ -1559,4 +1307,256 @@ const liveDual = (self, reason) => self.live(reason);
 const live = dual(2, liveDual);
 const make = (bindings) => (name) => declared(bindings, name, void 0);
 //#endregion
+//#region src/judge-tempo-answer.workflow.ts
+const JudgeTempoAnswerTypeId = Symbol.for("@systemfsoftware/trace-spec/JudgeTempoAnswer");
+var TempoBodyDecoded = class extends Schema.TaggedClass()("TempoBodyDecoded", {
+	spans: Schema.Array(SpanRecord),
+	status: Schema.optional(Schema.String)
+}) {};
+var TempoBodyUndecodable = class extends Schema.TaggedClass()("TempoBodyUndecodable", { detail: Schema.String }) {};
+const TempoBody = Schema.Union([TempoBodyDecoded, TempoBodyUndecodable]);
+var TempoAnswerComplete = class extends Schema.TaggedClass()("TempoAnswerComplete", { spans: Schema.Array(SpanRecord) }) {
+	[JudgeTempoAnswerTypeId] = JudgeTempoAnswerTypeId;
+};
+var TempoAnswerIncomplete = class extends Schema.TaggedClass()("TempoAnswerIncomplete", {
+	status: Schema.String,
+	spanCount: Schema.Int
+}) {
+	[JudgeTempoAnswerTypeId] = JudgeTempoAnswerTypeId;
+};
+var TempoAnswerUndecodable = class extends Schema.TaggedClass()("TempoAnswerUndecodable", { detail: Schema.String }) {
+	[JudgeTempoAnswerTypeId] = JudgeTempoAnswerTypeId;
+};
+const TempoAnswerDecision = Schema.Union([
+	TempoAnswerComplete,
+	TempoAnswerIncomplete,
+	TempoAnswerUndecodable
+]);
+var JudgeTempoAnswer = class extends Schema.TaggedClass()("JudgeTempoAnswer", { body: TempoBody }) {
+	static [Workflow.InstrumentationBrand] = {};
+};
+const isComplete = (status) => Option.match(status, {
+	onNone: () => true,
+	onSome: (marked) => marked === "COMPLETE"
+});
+const classify = (spans, status) => Match.value(isComplete(status)).pipe(Match.when(true, () => new TempoAnswerComplete({ spans })), Match.when(false, () => new TempoAnswerIncomplete({
+	status: Option.getOrElse(status, () => "INCOMPLETE"),
+	spanCount: spans.length
+})), Match.exhaustive);
+const decide = (command) => Result$1.succeed(Match.value(command.body).pipe(Match.tag("TempoBodyDecoded", (decoded) => classify(decoded.spans, Option.fromUndefinedOr(decoded.status))), Match.tag("TempoBodyUndecodable", (undecodable) => new TempoAnswerUndecodable({ detail: undecodable.detail })), Match.exhaustive));
+const judgeTempoAnswer = Workflow.make({
+	command: JudgeTempoAnswer,
+	decision: TempoAnswerDecision,
+	error: Schema.Never,
+	decide
+});
+//#endregion
+//#region src/tempo-trace.schema.ts
+/** Proto bytes (base64 on the wire) as the lowercase hex ids traces are addressed by. */
+const HexId = Schema.Uint8ArrayFromBase64.pipe(Schema.decodeTo(Schema.String, {
+	decode: SchemaGetter.transform(Hex.encode),
+	encode: SchemaGetter.decodeHex()
+}));
+const secondsAndNanos = (nanos) => {
+	const text = nanos.padStart(10, "0");
+	return [Number(text.slice(0, -9)), Number(text.slice(-9))];
+};
+const millisOf = (nanos) => {
+	const [seconds, subMillis] = secondsAndNanos(nanos);
+	return seconds * 1e3 + subMillis / 1e6;
+};
+const MillisFromNanos = Schema.String.pipe(Schema.decodeTo(Schema.Finite, SchemaTransformation.transform({
+	decode: millisOf,
+	encode: (millis) => String(Math.round(millis * 1e6))
+})));
+const unsetParent = (parent) => parent === "" || /^0+$/.test(parent);
+const heldParent = (parent) => unsetParent(parent) ? null : parent;
+const parentOf = (parent) => heldParent(parent ?? "");
+const EMPTY_STATUS = {};
+const codeOf = (status) => status.code ?? "STATUS_CODE_UNSET";
+const STATUS_BY_CODE = {
+	STATUS_CODE_UNSET: "unset",
+	STATUS_CODE_OK: "ok",
+	STATUS_CODE_ERROR: "error"
+};
+const statusOf = (status) => STATUS_BY_CODE[codeOf(status ?? EMPTY_STATUS)];
+const stringValueOf = (value) => value.stringValue ?? null;
+const numberOf = (value) => value.doubleValue ?? intToNumber(value.intValue);
+const intToNumber = (text) => text === void 0 ? null : Number(text);
+const boolOrNumberOf = (value) => value.boolValue ?? numberOf(value);
+const scalarOf = (value) => stringValueOf(value) ?? boolOrNumberOf(value);
+const isScalarMember = (member) => member !== null;
+const arrayValuesOf = (value) => value.arrayValue?.values;
+const scalarMembersOf = (values) => values.map(scalarOf).filter(isScalarMember);
+const arrayValueOf = (values) => values === void 0 ? null : scalarMembersOf(values);
+const presentValueOf = (value) => scalarOf(value) ?? arrayValueOf(arrayValuesOf(value));
+const isPresent = (entry) => entry[1] !== null;
+const entryOf = (attribute) => [attribute.key, attributeValueOf(attribute.value)];
+const attributeValueOf = (value) => value === void 0 ? null : presentValueOf(value);
+const attributesOf = (attributes) => Object.fromEntries((attributes ?? []).map(entryOf).filter(isPresent));
+const errorTypeOf = (attributes) => {
+	const value = attributes["error.type"];
+	return typeof value === "string" ? value : null;
+};
+const eventOf = (event) => ({
+	name: event.name,
+	attributes: attributesOf(event.attributes)
+});
+const linkIdOf = (id) => id ?? "";
+const linkOf = (link) => ({
+	traceId: linkIdOf(link.traceId),
+	spanId: linkIdOf(link.spanId)
+});
+const eventsOf = (span) => (span.events ?? []).map(eventOf);
+const linksOf = (span) => (span.links ?? []).map(linkOf);
+const spanRecordOf = (span) => {
+	const attributes = attributesOf(span.attributes);
+	return {
+		traceId: span.traceId,
+		spanId: span.spanId,
+		parentSpanId: parentOf(span.parentSpanId),
+		name: span.name,
+		status: statusOf(span.status),
+		errorType: errorTypeOf(attributes),
+		startMillis: span.startTimeUnixNano,
+		durationMillis: span.endTimeUnixNano - span.startTimeUnixNano,
+		attributes,
+		events: eventsOf(span),
+		links: linksOf(span)
+	};
+};
+const wireTextOf = (value) => typeof value === "string" ? { stringValue: value } : void 0;
+const wireBoolOf = (value) => typeof value === "boolean" ? { boolValue: value } : void 0;
+const isValueArray = (value) => Array.isArray(value);
+const wireArrayOf = (value) => ({ arrayValue: { values: isValueArray(value) ? value.map(wireValueOf) : [] } });
+const wireNumberOrArrayOf = (value) => typeof value === "number" ? { doubleValue: value } : wireArrayOf(value);
+const wireBoolOrNumberOf = (value) => wireBoolOf(value) ?? wireNumberOrArrayOf(value);
+const wireValueOf = (value) => wireTextOf(value) ?? wireBoolOrNumberOf(value);
+const wireAttributesOf = (attributes) => Object.entries(attributes).map(([key, value]) => ({
+	key,
+	value: wireValueOf(value)
+}));
+const STATUS_CODE_BY_STATUS = {
+	unset: "STATUS_CODE_UNSET",
+	ok: "STATUS_CODE_OK",
+	error: "STATUS_CODE_ERROR"
+};
+const wireStatusOf = (status) => ({ code: STATUS_CODE_BY_STATUS[status] });
+const wireSpanOf = (record) => ({
+	traceId: record.traceId,
+	spanId: record.spanId,
+	parentSpanId: record.parentSpanId ?? void 0,
+	name: record.name,
+	startTimeUnixNano: record.startMillis,
+	endTimeUnixNano: record.startMillis + record.durationMillis,
+	attributes: wireAttributesOf(record.attributes),
+	events: record.events.map((event) => ({
+		name: event.name,
+		attributes: wireAttributesOf(event.attributes)
+	})),
+	links: record.links.map((link) => ({
+		traceId: link.traceId,
+		spanId: link.spanId
+	})),
+	status: wireStatusOf(record.status)
+});
+const WireAnyValue = Schema.Struct({
+	stringValue: Schema.optional(Schema.String),
+	boolValue: Schema.optional(Schema.Boolean),
+	intValue: Schema.optional(Schema.String),
+	doubleValue: Schema.optional(Schema.Finite),
+	arrayValue: Schema.optional(Schema.Struct({ values: Schema.optional(Schema.Array(Schema.suspend(() => WireAnyValue))) }))
+});
+const WireAttribute = Schema.Struct({
+	key: Schema.String,
+	value: Schema.optional(WireAnyValue)
+});
+const WireStatus = Schema.Struct({
+	message: Schema.optional(Schema.String),
+	code: Schema.optional(Schema.Literals([
+		"STATUS_CODE_UNSET",
+		"STATUS_CODE_OK",
+		"STATUS_CODE_ERROR"
+	]))
+});
+const WireEvent = Schema.Struct({
+	name: Schema.String,
+	timeUnixNano: Schema.optional(MillisFromNanos),
+	attributes: Schema.optional(Schema.Array(WireAttribute))
+});
+const WireLink = Schema.Struct({
+	traceId: Schema.optional(HexId),
+	spanId: Schema.optional(HexId)
+});
+const WireSpan = Schema.Struct({
+	traceId: HexId,
+	spanId: HexId,
+	parentSpanId: Schema.optional(HexId),
+	name: Schema.String,
+	kind: Schema.optional(Schema.String),
+	startTimeUnixNano: MillisFromNanos,
+	endTimeUnixNano: MillisFromNanos,
+	attributes: Schema.optional(Schema.Array(WireAttribute)),
+	events: Schema.optional(Schema.Array(WireEvent)),
+	links: Schema.optional(Schema.Array(WireLink)),
+	status: Schema.optional(WireStatus),
+	traceState: Schema.optional(Schema.String),
+	flags: Schema.optional(Schema.Finite)
+}).pipe(Schema.decodeTo(SpanRecord, SchemaTransformation.transform({
+	decode: spanRecordOf,
+	encode: wireSpanOf
+})));
+const WireScopeSpans = Schema.Struct({ spans: Schema.optional(Schema.Array(WireSpan)) });
+const WireResourceSpans = Schema.Struct({ scopeSpans: Schema.optional(Schema.Array(WireScopeSpans)) });
+/** One trace-by-id answer: the spans, plus the store's completeness status when it is not complete. */
+const TempoV2TraceResponse = Schema.Struct({
+	trace: Schema.Struct({ resourceSpans: Schema.optional(Schema.Array(WireResourceSpans)) }),
+	status: Schema.optional(Schema.String),
+	message: Schema.optional(Schema.String)
+});
+//#endregion
+//#region src/tempo-trace-store.ts
+var tempo_trace_store_exports = /* @__PURE__ */ __exportAll({ source: () => source });
+/**
+* The Grafana Tempo trace source: one read of one trace by id against one
+* store endpoint. It never polls, waits, or retries — completeness belongs
+* to the remote observation layer. Any refusal (unreachable endpoint,
+* non-2xx answer, undecodable body) fails with the transport failure whose
+* `source` is the request URL; an answer the store marked incomplete fails
+* with the incomplete failure, since waiting cannot complete it.
+*/
+const parseBody = Schema.decodeResult(Schema.fromJsonString(TempoV2TraceResponse));
+const orEmpty = (values) => values ?? [];
+const spansOf = (response) => orEmpty(response.trace.resourceSpans).flatMap((resourceSpans) => orEmpty(resourceSpans.scopeSpans).flatMap((scopeSpans) => orEmpty(scopeSpans.spans)));
+const bodyOf = (decoded) => Result.match(decoded, {
+	onFailure: (error) => new TempoBodyUndecodable({ detail: error.message }),
+	onSuccess: (response) => new TempoBodyDecoded({
+		spans: spansOf(response),
+		status: response.status
+	})
+});
+const transportFailureOf = (traceId, url, cause) => new TransportObservationError({
+	traceId,
+	source: url,
+	detail: cause
+});
+const refusedOf = (traceId, url, error) => transportFailureOf(traceId, url, error.message);
+const undecodableOf = (traceId, url, detail) => transportFailureOf(traceId, url, `undecodable trace body: ${detail}`);
+const incompleteOf = (traceId, status, spanCount) => new IncompleteObservationError({
+	traceId,
+	spanCount,
+	detail: `the store answered ${status}: waiting cannot complete the trace`
+});
+const readTrace = (traceId, url, body) => Effect.flatMap(Effect.fromResult(judgeTempoAnswer(new JudgeTempoAnswer({ body: bodyOf(parseBody(body)) }))), (decision) => Match.value(decision).pipe(Match.tag("TempoAnswerComplete", (complete) => Effect.succeed(complete.spans)), Match.tag("TempoAnswerIncomplete", (incomplete) => Effect.fail(incompleteOf(traceId, incomplete.status, incomplete.spanCount))), Match.tag("TempoAnswerUndecodable", (undecodable) => Effect.fail(undecodableOf(traceId, url, undecodable.detail))), Match.exhaustive));
+/** One read against one Tempo endpoint. Its only requirement is the caller's HTTP client. */
+const source = (options) => {
+	const urlOf = (traceId) => `${options.baseUrl}/api/v2/traces/${traceId}`;
+	return (traceId) => {
+		const url = urlOf(traceId);
+		return HttpClient.execute(HttpClientRequest.get(url).pipe(HttpClientRequest.acceptJson)).pipe(Effect.flatMap(HttpClientResponse.filterStatusOk), Effect.flatMap((response) => response.text), Effect.mapError((error) => refusedOf(traceId, url, error)), Effect.flatMap((body) => readTrace(traceId, url, body)));
+	};
+};
+Schema.decodeEffect(HexId);
+Schema.encodeEffect(HexId);
+//#endregion
 export { Contract_exports as Contract, Graph_exports as Graph, Observation_service_exports as Observation, observation_window_blueprint_exports as ObservationWindow, Rel_exports as Rel, RemoteObservation_exports as RemoteObservation, Stimulus_exports as Stimulus, Suite_exports as Suite, tempo_trace_store_exports as TempoTraceStore };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@systemfsoftware/trace-spec",
   "license": "Apache-2.0",
-  "version": "1.0.1",
+  "version": "1.2.4",
   "author": "Ryan Lee <drdgvhbh@gmail.com>",
   "repository": {
     "type": "git",
@@ -33,44 +33,43 @@
     "dist"
   ],
   "dependencies": {
-    "@effect/opentelemetry": "^4",
+    "@effect/opentelemetry": "^4.1.2",
     "@opentelemetry/api": "^1.9.0",
-    "@opentelemetry/resources": "^2",
-    "@opentelemetry/sdk-trace-base": "^2",
-    "@opentelemetry/semantic-conventions": "^1.33",
-    "@systemfsoftware/effect-cell-types": "^12.0.0",
-    "@systemfsoftware/effect-spec-runtime": "^1.0.1",
-    "@systemfsoftware/trace-taxonomy": "^1.0.0"
+    "@opentelemetry/resources": "^2.12.0",
+    "@opentelemetry/sdk-trace-base": "^2.12.0",
+    "@opentelemetry/semantic-conventions": "^1.43.0",
+    "@systemfsoftware/effect-cell-types": "^12.1.4",
+    "@systemfsoftware/effect-spec-runtime": "^1.1.5",
+    "@systemfsoftware/trace-taxonomy": "^1.0.6"
   },
   "devDependencies": {
-    "@effect/platform-node": "^4",
+    "@effect/platform-node": "^4.1.2",
     "@systemfsoftware/arethetypeswrong-cli": "^4.2.0",
-    "@systemfsoftware/conformance-spec": "^1.0.0",
-    "@systemfsoftware/effect-gherkin-spec": "^7.0.1",
-    "@systemfsoftware/oxlint-config-recommended": "^4.0.0",
-    "@systemfsoftware/stryker-config": "^0.1.0",
+    "@systemfsoftware/conformance-spec": "^1.1.4",
+    "@systemfsoftware/effect-gherkin-spec": "^8.1.4",
+    "@systemfsoftware/oxlint-config-recommended": "^6.0.1",
+    "@systemfsoftware/stryker-config": "^0.2.1",
     "@systemfsoftware/stryker-ignorer-effect-schema-declarations": "latest",
     "@systemfsoftware/stryker-ignorer-in-source-vitest-block": "latest",
     "@systemfsoftware/stryker-js": "latest",
     "@systemfsoftware/stryker-js-typescript-checker": "latest",
     "@systemfsoftware/stryker-js-vitest-runner": "latest",
-    "@systemfsoftware/stryker-test-contribution": "latest",
-    "@systemfsoftware/tsconfig": "^2.0.1",
-    "@systemfsoftware/tsdown-config": "^0.1.0",
-    "@systemfsoftware/vitest": "^2.0.0",
-    "@systemfsoftware/vitest-config": "^0.1.0",
-    "@types/node": "^26",
-    "effect": "^4",
-    "oxlint": "~1.82.0",
+    "@systemfsoftware/tsconfig": "^2.1.0",
+    "@systemfsoftware/tsdown-config": "^0.1.2",
+    "@systemfsoftware/vitest": "^4.1.1",
+    "@systemfsoftware/vitest-config": "^0.1.3",
+    "@types/node": "^26.6.5",
+    "effect": "^4.1.2",
+    "oxlint": "~1.89.0",
     "rimraf": "^6.1.3",
     "tsdown": "^0.23.0",
     "tstyche": "^7.2.5",
-    "vitest": "^5"
+    "vitest": "^5.1.0"
   },
   "peerDependencies": {
-    "@systemfsoftware/vitest": "^2.0.0",
-    "effect": "^4",
-    "vitest": "^5"
+    "@systemfsoftware/vitest": "^4.1.1",
+    "effect": "^4.1.2",
+    "vitest": "^5.1.0"
   },
   "publishConfig": {
     "access": "public",
@@ -82,7 +81,6 @@
     "typecheck": "tsc -b",
     "test": "vitest run",
     "mutation": "stryker run",
-    "mutation:full": "stryker run --force",
     "test:types": "TSTYCHE_TYPESCRIPT_MODULE=tstyche-typescript tstyche",
     "lint": "f=${OXLINT_FORMAT:-${AGENT:+agent}}; oxlint . --format=${f:-default}",
     "attw": "attw --pack ."