@systemfsoftware/trace-spec 0.5.1 → 0.5.2

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # @systemfsoftware/trace-spec
 
+## 0.5.2
+
+### Patch Changes
+
+- Updated dependencies:
+  - @systemfsoftware/vitest@0.3.0
+
 ## 0.5.1
 
 ### Patch Changes

package/dist/index.d.ts

@@ -1,9 +1,10 @@
-import { Context, Duration, Effect, FileSystem, Layer, Result, Schema } from "effect";
+import { Context, Duration, Effect, FileSystem, Layer, Option, Schema } from "effect";
 import { Pipeable } from "effect/Pipeable";
 import { Span, Taxonomy } from "@systemfsoftware/trace-taxonomy";
+import * as Result$1 from "effect/Result";
 import * as HttpClient from "effect/unstable/http/HttpClient";
-import * as OtelTracer from "@effect/opentelemetry/OtelTracer";
 import { Blueprint, Handle } from "@systemfsoftware/effect-cell-types";
+import * as OtelTracer from "@effect/opentelemetry/OtelTracer";
 import { BasicTracerProvider, ReadableSpan } from "@opentelemetry/sdk-trace-base";
 import { Suite } from "@systemfsoftware/effect-spec-runtime";
 import { Asserted, Check, Expect } from "@systemfsoftware/vitest";
@@ -126,9 +127,7 @@ declare const TraceGraph: Schema.Struct<{
   }>>;
 }>;
 type TraceGraph = typeof TraceGraph.Type;
-declare namespace Graph_d_exports {
-  export { AttributeValue, Attributes, GraphNode, SpanEvent, SpanLink, SpanRecord, Status, TraceGraph, byId, children, decode, descendants };
-}
+type GraphDecoded = Result$1.Result<TraceGraph, ContractDecodeError>;
 declare const byId: {
   (spec: Span.Span): (graph: TraceGraph) => ReadonlyArray<GraphNode>;
   (graph: TraceGraph, spec: Span.Span): ReadonlyArray<GraphNode>;
@@ -149,9 +148,12 @@ declare const descendants: {
  * fail the pipeline by accident.
  */
 declare const decode: {
-  (spans: ReadonlyArray<SpanRecord>, taxonomy: Taxonomy.Taxonomy): (traceId: string) => Result.Result<TraceGraph, ContractDecodeError>;
-  (traceId: string, spans: ReadonlyArray<SpanRecord>, taxonomy: Taxonomy.Taxonomy): Result.Result<TraceGraph, ContractDecodeError>;
+  (spans: ReadonlyArray<SpanRecord>, taxonomy: Taxonomy.Taxonomy): (traceId: string) => GraphDecoded;
+  (traceId: string, spans: ReadonlyArray<SpanRecord>, taxonomy: Taxonomy.Taxonomy): GraphDecoded;
 };
+declare namespace Graph_d_exports {
+  export { AttributeValue, Attributes, GraphDecoded, GraphNode, SpanEvent, SpanLink, SpanRecord, Status, TraceGraph, byId, children, decode, descendants };
+}
 //#endregion
 //#region src/TransportObservationError.schema.d.ts
 declare const TransportObservationError_base: Schema.Class<TransportObservationError, Schema.TaggedStruct<"TransportObservationError", {

package/dist/index.mjs

@@ -1,18 +1,18 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
 import { callFrameOutside, withRaisingFrame } from "@systemfsoftware/vitest/failure";
 import { Array as Array$1, Cause, Clock, Context, Duration, Effect, Encoding, Equal, FileSystem, Layer, Match, Option, Predicate, Random, Ref, Result, Schema, SchemaGetter, SchemaTransformation } from "effect";
-import { dual } from "effect/Function";
+import { absurd, dual } from "effect/Function";
 import { Prototype } from "effect/Pipeable";
 import "effect/PlatformError";
 import "@systemfsoftware/trace-taxonomy";
 import "effect/Array";
-import "effect/Result";
+import * as Result$1 from "effect/Result";
 import * as HttpClient from "effect/unstable/http/HttpClient";
 import * as HttpClientRequest from "effect/unstable/http/HttpClientRequest";
 import * as HttpClientResponse from "effect/unstable/http/HttpClientResponse";
+import { Blueprint, Handle, Workflow } from "@systemfsoftware/effect-cell-types";
 import * as OtelTracer from "@effect/opentelemetry/OtelTracer";
 import * as OtelResource from "@effect/opentelemetry/Resource";
-import { Blueprint, Handle } 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";
@@ -46,64 +46,6 @@ var EmptyObservationError = class extends Schema.TaggedError()("EmptyObservation
 	}
 };
 //#endregion
-//#region src/Verdict.schema.ts
-const Hold = Schema.TaggedStruct("Hold", {
-	conjunct: Schema.String,
-	inspected: Schema.Array(Schema.String)
-});
-const Break = Schema.TaggedStruct("Break", {
-	conjunct: Schema.String,
-	inspected: Schema.Array(Schema.String),
-	detail: Schema.String
-});
-const Verdict = Schema.Union([Hold, Break]);
-//#endregion
-//#region src/FailureDump.ts
-const DEFAULT_DIRECTORY = "artifacts/traces";
-const isBreak$1 = Schema.is(Break);
-/**
-* The rendered evidence a break carries; a held verdict leaves nothing to write.
-*/
-const report = (verdict) => Option.map(Option.liftPredicate(verdict, isBreak$1), renderBreach);
-const renderValue = (value) => JSON.stringify(value);
-const renderEntries = (entries) => [...entries].map(([key, value]) => `${key}=${renderValue(value)}`).join(" ");
-const indentOf = (depth) => "  ".repeat(depth);
-const renderBreach = (breach) => `break ${breach.conjunct} inspected=[${breach.inspected.join(", ")}]\n${indentOf(1)}${breach.detail}`;
-const childrenOf = (spans, spanId) => spans.filter((span) => span.parentSpanId === spanId);
-const renderNode = (spans, node, depth) => {
-	return [`${indentOf(depth)}${node.name} (${node.spanId}) status=${node.status} error.type=${String(node.errorType)} duration=${node.durationMillis}ms`, ...[
-		`${indentOf(depth)}  attrs: ${renderEntries(Object.entries(node.attributes))}`,
-		...node.events.map((event) => `${indentOf(depth)}  event ${event.name} ${renderEntries(Object.entries(event.attributes))}`),
-		...node.links.map((link) => `${indentOf(depth)}  link ${link.traceId}/${link.spanId}`),
-		...childrenOf(spans, node.spanId).map((child) => renderNode(spans, child, depth + 1))
-	]].join("\n");
-};
-const documentImpl = (observed, report) => [
-	`trace ${observed.traceId}`,
-	report,
-	...observed.spans.map((node) => renderNode(observed.spans, node, 0))
-].join("\n");
-/**
-* The dump document: the trace it belongs to, the break that refused it, and the recorded
-* spans as the observation window saw them.
-*/
-const document = dual(2, documentImpl);
-const sanitize = (value) => value.replace(/[^a-zA-Z0-9._-]+/g, "-");
-const fileNameOf = (request) => `${sanitize(request.name ?? request.traceId)}.${sanitize(request.conjunct)}.txt`;
-/**
-* Writes the dump under the artifacts directory and answers with its path. The file is
-* named after the request's name when one is given — a generated case names its dump after
-* itself, so every failing draw overwrites one file and the last write is the reported
-* counterexample.
-*/
-const write = (request) => Effect.gen(function* () {
-	const fs = yield* FileSystem.FileSystem;
-	yield* fs.makeDirectory(DEFAULT_DIRECTORY, { recursive: true });
-	const path = `${DEFAULT_DIRECTORY}/${fileNameOf(request)}`;
-	yield* fs.writeFileString(path, document(request, request.report));
-	return path;
-});
-//#endregion
 //#region src/TraceGraph.schema.ts
 const Status = Schema.Literals([
 	"ok",
@@ -159,22 +101,6 @@ const TraceGraph = Schema.Struct({
 	traceId: Schema.String,
 	nodes: Schema.Array(GraphNode)
 });
-//#endregion
-//#region src/Graph.ts
-var Graph_exports = /* @__PURE__ */ __exportAll({
-	AttributeValue: () => AttributeValue,
-	Attributes: () => Attributes,
-	GraphNode: () => GraphNode,
-	SpanEvent: () => SpanEvent,
-	SpanLink: () => SpanLink,
-	SpanRecord: () => SpanRecord,
-	Status: () => Status,
-	TraceGraph: () => TraceGraph,
-	byId: () => byId,
-	children: () => children,
-	decode: () => decode,
-	descendants: () => descendants
-});
 const byIdImpl = (graph, spec) => graph.nodes.filter((node) => node.name === spec.name);
 const byId = dual(2, byIdImpl);
 const childrenImpl = (graph, node) => graph.nodes.filter((candidate) => candidate.parentSpanId === node.spanId);
@@ -204,7 +130,7 @@ const decodeFailure = (spec, record, detail, attribute) => ContractDecodeError.m
 	attribute: attribute ?? "*",
 	detail
 });
-const decodeAttrs = (spec, record) => Result.mapError(Schema.decodeResult(Schema.toType(spec.attrs))(record.attributes), (error) => decodeFailure(spec, record, error.message, attributeNameOf(error.issue)));
+const decodeAttrs = (spec, record) => Result$1.mapError(Schema.decodeResult(Schema.toType(spec.attrs))(record.attributes), (error) => decodeFailure(spec, record, error.message, attributeNameOf(error.issue)));
 const nodeOf = (record, attrs) => ({
 	spanId: record.spanId,
 	parentSpanId: record.parentSpanId,
@@ -217,10 +143,10 @@ const nodeOf = (record, attrs) => ({
 	events: record.events,
 	links: record.links
 });
-const decodedNodeOf = (record, spec) => Result.map(decodeAttrs(spec, record), (attrs) => nodeOf(record, attrs));
+const decodedNodeOf = (record, spec) => Result$1.map(decodeAttrs(spec, record), (attrs) => nodeOf(record, attrs));
 const declaredNodeOf = (record, declarations) => {
 	const spec = declarations.get(record.name);
-	return spec === void 0 ? Result.succeed(nodeOf(record, record.attributes)) : decodedNodeOf(record, spec);
+	return spec === void 0 ? Result$1.succeed(nodeOf(record, record.attributes)) : decodedNodeOf(record, spec);
 };
 const graphOf = (traceId, nodes) => ({
 	traceId,
@@ -228,7 +154,7 @@ const graphOf = (traceId, nodes) => ({
 });
 const decodeImpl = (traceId, spans, taxonomy) => {
 	const declarations = indexDeclarations(taxonomy);
-	return Result.map(Result.all(spans.map((record) => declaredNodeOf(record, declarations))), (nodes) => graphOf(traceId, nodes));
+	return Result$1.map(Result$1.all(spans.map((record) => declaredNodeOf(record, declarations))), (nodes) => graphOf(traceId, nodes));
 };
 /**
 * Decodes the recorded spans of one trace against a taxonomy, purely: a declared span
@@ -238,6 +164,56 @@ const decodeImpl = (traceId, spans, taxonomy) => {
 * fail the pipeline by accident.
 */
 const decode = dual(3, decodeImpl);
+Schema.Struct({
+	traceId: Schema.String,
+	spans: Schema.Array(SpanRecord)
+});
+const renderValue = (value) => JSON.stringify(value);
+const renderEntries = (entries) => [...entries].map(([key, value]) => `${key}=${renderValue(value)}`).join(" ");
+const indentOf$1 = (depth) => "  ".repeat(depth);
+const childrenOf = (spans, spanId) => spans.filter((span) => span.parentSpanId === spanId);
+const renderNode = (spans, node, depth) => {
+	return [`${indentOf$1(depth)}${node.name} (${node.spanId}) status=${node.status} error.type=${String(node.errorType)} duration=${node.durationMillis}ms`, ...[
+		`${indentOf$1(depth)}  attrs: ${renderEntries(Object.entries(node.attributes))}`,
+		...node.events.map((event) => `${indentOf$1(depth)}  event ${event.name} ${renderEntries(Object.entries(event.attributes))}`),
+		...node.links.map((link) => `${indentOf$1(depth)}  link ${link.traceId}/${link.spanId}`),
+		...childrenOf(spans, node.spanId).map((child) => renderNode(spans, child, depth + 1))
+	]].join("\n");
+};
+const documentImpl = (observed, report) => [
+	`trace ${observed.traceId}`,
+	report,
+	...observed.spans.map((node) => renderNode(observed.spans, node, 0))
+].join("\n");
+const document = dual(2, documentImpl);
+//#endregion
+//#region src/FailureDump.ts
+const DEFAULT_DIRECTORY = "artifacts/traces";
+const sanitize = (value) => value.replace(/[^a-zA-Z0-9._-]+/g, "-");
+const fileNameOf = (request) => `${sanitize(request.name ?? request.traceId)}.${sanitize(request.conjunct)}.txt`;
+const write = (request) => Effect.gen(function* () {
+	const fs = yield* FileSystem.FileSystem;
+	yield* fs.makeDirectory(DEFAULT_DIRECTORY, { recursive: true });
+	const path = `${DEFAULT_DIRECTORY}/${fileNameOf(request)}`;
+	yield* fs.writeFileString(path, document(request, request.report));
+	return path;
+});
+//#endregion
+//#region src/Graph.ts
+var Graph_exports = /* @__PURE__ */ __exportAll({
+	AttributeValue: () => AttributeValue,
+	Attributes: () => Attributes,
+	GraphNode: () => GraphNode,
+	SpanEvent: () => SpanEvent,
+	SpanLink: () => SpanLink,
+	SpanRecord: () => SpanRecord,
+	Status: () => Status,
+	TraceGraph: () => TraceGraph,
+	byId: () => byId,
+	children: () => children,
+	decode: () => decode,
+	descendants: () => descendants
+});
 //#endregion
 //#region src/IncompleteObservationError.schema.ts
 const SpanCount = Schema.Int.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(0, { message: "a span count is a non-negative integer" })));
@@ -271,6 +247,22 @@ var Observation_service_exports = /* @__PURE__ */ __exportAll({
 });
 var Observation = class extends Context.Service()("@systemfsoftware/trace-spec/Observation") {};
 //#endregion
+//#region src/Verdict.schema.ts
+const Hold = Schema.TaggedStruct("Hold", {
+	conjunct: Schema.String,
+	inspected: Schema.Array(Schema.String)
+});
+const Break = Schema.TaggedStruct("Break", {
+	conjunct: Schema.String,
+	inspected: Schema.Array(Schema.String),
+	detail: Schema.String
+});
+const Verdict = Schema.Union([Hold, Break]);
+const isBreak = Schema.is(Break);
+const indentOf = (depth) => "  ".repeat(depth);
+const renderBreach = (breach) => `break ${breach.conjunct} inspected=[${breach.inspected.join(", ")}]\n${indentOf(1)}${breach.detail}`;
+const report = (verdict) => Option.map(Option.liftPredicate(verdict, isBreak), renderBreach);
+//#endregion
 //#region src/Contract.ts
 var Contract_exports = /* @__PURE__ */ __exportAll({
 	BreakFailure: () => BreakFailure,
@@ -280,7 +272,7 @@ var Contract_exports = /* @__PURE__ */ __exportAll({
 	TransportObservationError: () => TransportObservationError,
 	TypeId: () => TypeId$3,
 	check: () => check,
-	holds: () => holds,
+	holds: () => holds$1,
 	judge: () => judge,
 	of: () => of,
 	stimulate: () => stimulate,
@@ -312,14 +304,14 @@ const of = (taxonomy) => ({
 const stimulateDual = (self, stimulus) => stimulatedOf(self.taxonomy, stimulus);
 const stimulate = dual(2, stimulateDual);
 const holdsDual = (self, relation) => contractOf(self.taxonomy, self.stimulus, relation);
-const holds = dual(2, holdsDual);
+const holds$1 = dual(2, holdsDual);
 const isContract = (value) => Predicate.hasProperty(value, TypeId$3);
 const dumpOf = (observed, verdict, options) => Option.match(report(verdict), {
 	onNone: () => Effect.succeed(null),
-	onSome: (report) => Effect.map(Effect.option(write({
+	onSome: (rendered) => Effect.map(Effect.option(write({
 		...observed,
 		conjunct: verdict.conjunct,
-		report,
+		report: rendered,
 		name: options?.dumpName
 	})), Option.getOrNull)
 });
@@ -355,8 +347,8 @@ const reportOf = (relationId, judgment) => Match.value(judgment.verdict).pipe(Ma
 	].join("\n")
 })), Match.exhaustive);
 const verdictCheckWith = (self, expect, judgment, frame) => {
-	const report = reportOf(self.relation.id, judgment);
-	return report.verdict === "Break" ? Effect.die(withRaisingFrame(failureOfReport(report), frame)) : expect(report, report.report).toEqual(held);
+	const finding = reportOf(self.relation.id, judgment);
+	return finding.verdict === "Break" ? Effect.die(withRaisingFrame(failureOfReport(finding), frame)) : expect(finding, finding.report).toEqual(held);
 };
 const verdictCheckImpl = (self, expect, judgment) => verdictCheckWith(self, expect, judgment, callFrame());
 /**
@@ -374,6 +366,50 @@ 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, {
@@ -550,32 +586,27 @@ var tempo_trace_store_exports = /* @__PURE__ */ __exportAll({ source: () => sour
 */
 const parseBody = Schema.decodeResult(Schema.fromJsonString(TempoV2TraceResponse));
 const orEmpty = (values) => values ?? [];
-const resourceSpansOf = (response) => orEmpty(response.trace.resourceSpans);
-const scopeSpansOf = (resourceSpans) => orEmpty(resourceSpans.scopeSpans);
-const spansOfScope = (scopeSpans) => orEmpty(scopeSpans.spans);
-const spansOf = (response) => resourceSpansOf(response).flatMap((resourceSpans) => scopeSpansOf(resourceSpans).flatMap(spansOfScope));
+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, error) => transportFailureOf(traceId, url, `undecodable trace body: ${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 isComplete = (status) => status === void 0 || status === "COMPLETE";
-const markedOf = (response) => response.status ?? "INCOMPLETE";
-const recordsOf$1 = (traceId, response) => {
-	const spans = spansOf(response);
-	return isComplete(response.status) ? Effect.succeed(spans) : Effect.fail(incompleteOf(traceId, markedOf(response), spans.length));
-};
-const readTrace = (traceId, url, body) => {
-	const decoded = parseBody(body);
-	return Result.isFailure(decoded) ? Effect.fail(undecodableOf(traceId, url, decoded.failure)) : recordsOf$1(traceId, decoded.success);
-};
+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}`;
@@ -713,6 +744,199 @@ const ObservationWindows = Blueprint.make()(TypeId$1).steps({
 });
 const make$2 = (serviceName) => ObservationWindows.of(ObservationWindowSpec.make({ serviceName }));
 //#endregion
+//#region src/combine-any-relations.workflow.ts
+const CombineAnyRelationsTypeId = Symbol.for("@systemfsoftware/trace-spec/CombineAnyRelations");
+/** At least one relation held, so the disjunction holds over every inspected span. */
+var AnyRelationHeld = class extends Schema.TaggedClass()("AnyRelationHeld", {
+	conjunct: Schema.String,
+	inspected: Schema.Array(Schema.String)
+}) {
+	[CombineAnyRelationsTypeId] = CombineAnyRelationsTypeId;
+};
+/** No relation held: every conjunct is named in the break. */
+var NoRelationHeld = class extends Schema.TaggedClass()("NoRelationHeld", {
+	conjunct: Schema.String,
+	inspected: Schema.Array(Schema.String),
+	detail: Schema.String
+}) {
+	[CombineAnyRelationsTypeId] = CombineAnyRelationsTypeId;
+};
+const CombineAnyRelationsDecision = Schema.Union([AnyRelationHeld, NoRelationHeld]);
+var CombineAnyRelations = class extends Schema.TaggedClass()("CombineAnyRelations", {
+	conjunct: Schema.String,
+	verdicts: Schema.Array(Verdict)
+}) {
+	static [Workflow.InstrumentationBrand] = {};
+};
+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({
+	conjunct: command.conjunct,
+	inspected: inspectedOf$1(command.verdicts)
+})), Match.when(false, () => new NoRelationHeld({
+	conjunct: command.conjunct,
+	inspected: inspectedOf$1(command.verdicts),
+	detail: namedConjuncts(command.verdicts)
+})), Match.exhaustive));
+/** `any(...)`: holds as soon as one relation holds, and otherwise breaks naming every conjunct. */
+const combineAnyRelations = Workflow.make({
+	command: CombineAnyRelations,
+	decision: CombineAnyRelationsDecision,
+	error: Schema.Never,
+	decide: decide$4
+});
+//#endregion
+//#region src/combine-relation-verdicts.workflow.ts
+const CombineRelationVerdictsTypeId = Symbol.for("@systemfsoftware/trace-spec/CombineRelationVerdicts");
+const EvaluatedRelation = Schema.Struct({
+	verdict: Verdict,
+	soft: Schema.Boolean
+});
+var FirstHardBreak = class extends Schema.TaggedClass()("FirstHardBreak", {
+	conjunct: Schema.String,
+	inspected: Schema.Array(Schema.String),
+	detail: Schema.String
+}) {
+	[CombineRelationVerdictsTypeId] = CombineRelationVerdictsTypeId;
+};
+var AggregatedSoftBreak = class extends Schema.TaggedClass()("AggregatedSoftBreak", {
+	conjunct: Schema.String,
+	inspected: Schema.Array(Schema.String),
+	detail: Schema.String
+}) {
+	[CombineRelationVerdictsTypeId] = CombineRelationVerdictsTypeId;
+};
+var EveryRelationHeld = class extends Schema.TaggedClass()("EveryRelationHeld", {
+	conjunct: Schema.String,
+	inspected: Schema.Array(Schema.String)
+}) {
+	[CombineRelationVerdictsTypeId] = CombineRelationVerdictsTypeId;
+};
+const CombineRelationVerdictsDecision = Schema.Union([
+	FirstHardBreak,
+	AggregatedSoftBreak,
+	EveryRelationHeld
+]);
+var CombineRelationVerdicts = class extends Schema.TaggedClass()("CombineRelationVerdicts", {
+	conjunct: Schema.String,
+	verdicts: Schema.Array(EvaluatedRelation)
+}) {
+	static [Workflow.InstrumentationBrand] = {};
+};
+const asBreak = (entry) => Match.value(entry.verdict).pipe(Match.tag("Break", (breach) => Option.some(breach)), Match.tag("Hold", () => Option.none()), Match.exhaustive);
+const breaksIn = (entries) => Array$1.flatMap(entries, (entry) => Option.match(asBreak(entry), {
+	onNone: () => [],
+	onSome: (breach) => [breach]
+}));
+const firstHardBreak = (verdicts) => Array$1.head(breaksIn(Array$1.filter(verdicts, (entry) => !entry.soft)));
+const softBreaks = (verdicts) => breaksIn(Array$1.filter(verdicts, (entry) => entry.soft));
+const aggregateSoft = (command) => {
+	const breaks = softBreaks(command.verdicts);
+	return Option.match(Array$1.head(breaks), {
+		onNone: () => new EveryRelationHeld({
+			conjunct: command.conjunct,
+			inspected: []
+		}),
+		onSome: () => new AggregatedSoftBreak({
+			conjunct: command.conjunct,
+			inspected: Array$1.flatMap(breaks, (breach) => breach.inspected),
+			detail: Array$1.join(Array$1.map(breaks, (breach) => breach.conjunct), ", ")
+		})
+	});
+};
+const decide$3 = (command) => Result$1.succeed(Option.match(firstHardBreak(command.verdicts), {
+	onNone: () => aggregateSoft(command),
+	onSome: (winner) => new FirstHardBreak({
+		conjunct: winner.conjunct,
+		inspected: winner.inspected,
+		detail: winner.detail
+	})
+}));
+const combineRelationVerdicts = Workflow.make({
+	command: CombineRelationVerdicts,
+	decision: CombineRelationVerdictsDecision,
+	error: Schema.Never,
+	decide: decide$3
+});
+//#endregion
+//#region src/judge-edge-placement.workflow.ts
+const JudgeEdgePlacementTypeId = Symbol.for("@systemfsoftware/trace-spec/JudgeEdgePlacement");
+var EdgePlacementHeld = class extends Schema.TaggedClass()("EdgePlacementHeld", {
+	conjunct: Schema.String,
+	inspected: Schema.Array(Schema.String)
+}) {
+	[JudgeEdgePlacementTypeId] = JudgeEdgePlacementTypeId;
+};
+var EdgePlacementBroken = class extends Schema.TaggedClass()("EdgePlacementBroken", {
+	conjunct: Schema.String,
+	inspected: Schema.Array(Schema.String),
+	detail: Schema.String
+}) {
+	[JudgeEdgePlacementTypeId] = JudgeEdgePlacementTypeId;
+};
+const JudgeEdgePlacementDecision = Schema.Union([EdgePlacementHeld, EdgePlacementBroken]);
+var JudgeEdgePlacement = class extends Schema.TaggedClass()("JudgeEdgePlacement", {
+	conjunct: Schema.String,
+	placed: Schema.Array(Schema.String),
+	reached: Schema.Array(Schema.String),
+	detail: Schema.String
+}) {
+	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({
+	conjunct: command.conjunct,
+	inspected: command.placed
+})), Match.when(false, () => new EdgePlacementBroken({
+	conjunct: command.conjunct,
+	inspected: command.placed,
+	detail: command.detail
+})), Match.exhaustive));
+const judgeEdgePlacement = Workflow.make({
+	command: JudgeEdgePlacement,
+	decision: JudgeEdgePlacementDecision,
+	error: Schema.Never,
+	decide: decide$2
+});
+//#endregion
+//#region src/negate-relation-verdict.workflow.ts
+const NegateRelationVerdictTypeId = Symbol.for("@systemfsoftware/trace-spec/NegateRelationVerdict");
+var HoldNegated = class extends Schema.TaggedClass()("HoldNegated", {
+	conjunct: Schema.String,
+	inspected: Schema.Array(Schema.String),
+	detail: Schema.String
+}) {
+	[NegateRelationVerdictTypeId] = NegateRelationVerdictTypeId;
+};
+var BreakNegated = class extends Schema.TaggedClass()("BreakNegated", {
+	conjunct: Schema.String,
+	inspected: Schema.Array(Schema.String)
+}) {
+	[NegateRelationVerdictTypeId] = NegateRelationVerdictTypeId;
+};
+const NegateRelationVerdictDecision = Schema.Union([HoldNegated, BreakNegated]);
+var NegateRelationVerdict = class extends Schema.TaggedClass()("NegateRelationVerdict", {
+	conjunct: Schema.String,
+	verdict: Verdict
+}) {
+	static [Workflow.InstrumentationBrand] = {};
+};
+const decide$1 = (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`
+})), Match.tag("Break", (breach) => new BreakNegated({
+	conjunct: command.conjunct,
+	inspected: breach.inspected
+})), Match.exhaustive));
+const negateRelationVerdict = Workflow.make({
+	command: NegateRelationVerdict,
+	decision: NegateRelationVerdictDecision,
+	error: Schema.Never,
+	decide: decide$1
+});
+//#endregion
 //#region src/Rel.ts
 var Rel_exports = /* @__PURE__ */ __exportAll({
 	Break: () => Break,
@@ -736,6 +960,10 @@ var Rel_exports = /* @__PURE__ */ __exportAll({
 	status: () => status,
 	unique: () => unique
 });
+const decisionOf = (result) => Result.match(result, {
+	onFailure: (unreachable) => absurd(unreachable),
+	onSuccess: (decision) => decision
+});
 const relation = (parts) => Object.assign((graph) => parts.evaluate(graph), {
 	id: parts.id,
 	soft: parts.soft,
@@ -744,9 +972,7 @@ const relation = (parts) => Object.assign((graph) => parts.evaluate(graph), {
 const matchedNodes = (graph, spec) => byId(graph, spec);
 const inspectedOf = (nodes) => nodes.map((node) => node.spanId);
 const matchedAll = (items, predicate) => items.length > 0 && items.every(predicate);
-const isBreak = (verdict) => Schema.is(Break)(verdict);
-const isHold$1 = (verdict) => Schema.is(Hold)(verdict);
-const verdictOf$1 = (options) => options.holds ? Hold.make({
+const verdictOf = (options) => options.holds ? Hold.make({
 	conjunct: options.id,
 	inspected: options.inspected
 }) : Break.make({
@@ -760,7 +986,7 @@ const declared$1 = (declaration) => relation({
 	softenable: declaration.softenable,
 	evaluate: (graph) => {
 		const inspected = declaration.spans.flatMap((span) => inspectedOf(byId(graph, span)));
-		return verdictOf$1({
+		return verdictOf({
 			id: declaration.id,
 			inspected,
 			holds: declaration.holds(graph),
@@ -873,7 +1099,7 @@ const forallImpl = (spec, predicate, detail) => {
 		softenable: true,
 		evaluate: (graph) => {
 			const nodes = matchedNodes(graph, spec);
-			return verdictOf$1({
+			return verdictOf({
 				id,
 				inspected: inspectedOf(nodes),
 				holds: matchedAll(nodes, predicate),
@@ -889,13 +1115,16 @@ const soft = (self) => self.softenable ? relation({
 	softenable: true,
 	evaluate: (graph) => self(graph)
 }) : self;
-const negatedVerdict = (id, inner) => Match.value(inner).pipe(Match.tag("Hold", (held) => Break.make({
+const negatedVerdict = (id, inner) => Match.value(decisionOf(negateRelationVerdict(new NegateRelationVerdict({
 	conjunct: id,
+	verdict: inner
+})))).pipe(Match.tag("HoldNegated", (held) => Break.make({
+	conjunct: held.conjunct,
 	inspected: held.inspected,
-	detail: `${held.conjunct} held`
-})), Match.tag("Break", (breach) => Hold.make({
-	conjunct: id,
-	inspected: breach.inspected
+	detail: held.detail
+})), Match.tag("BreakNegated", (broken) => Hold.make({
+	conjunct: broken.conjunct,
+	inspected: broken.inspected
 })), Match.exhaustive);
 const not = (self) => {
 	const id = `not(${self.id})`;
@@ -906,24 +1135,29 @@ const not = (self) => {
 		evaluate: (graph) => negatedVerdict(id, self(graph))
 	});
 };
-const collectSoft = (id, breaks) => {
-	const inspected = breaks.flatMap((breach) => breach.inspected);
-	return breaks.length === 0 ? Hold.make({
-		conjunct: id,
-		inspected
-	}) : Break.make({
-		conjunct: id,
-		inspected,
-		detail: breaks.map((breach) => breach.conjunct).join(", ")
-	});
-};
-const firstHardBreak = (relations, graph) => relations.filter((relation) => !relation.soft).map((relation) => relation(graph)).find(isBreak) ?? null;
-const softBreaks = (relations, graph) => relations.filter((relation) => relation.soft).map((relation) => relation(graph)).filter(isBreak);
+const combinationOf = (conjunct, relations, graph) => Match.value(decisionOf(combineRelationVerdicts(new CombineRelationVerdicts({
+	conjunct,
+	verdicts: relations.map((relation) => ({
+		verdict: relation(graph),
+		soft: relation.soft
+	}))
+})))).pipe(Match.tag("FirstHardBreak", (winner) => Break.make({
+	conjunct: winner.conjunct,
+	inspected: winner.inspected,
+	detail: winner.detail
+})), Match.tag("AggregatedSoftBreak", (aggregated) => Break.make({
+	conjunct: aggregated.conjunct,
+	inspected: aggregated.inspected,
+	detail: aggregated.detail
+})), Match.tag("EveryRelationHeld", (held) => Hold.make({
+	conjunct: held.conjunct,
+	inspected: held.inspected
+})), Match.exhaustive);
 const combined = (options) => relation({
 	id: options.id,
 	soft: options.soft,
 	softenable: options.softenable,
-	evaluate: (graph) => firstHardBreak(options.relations, graph) ?? collectSoft(options.id, softBreaks(options.relations, graph))
+	evaluate: (graph) => combinationOf(options.id, options.relations, graph)
 });
 const all = (...relations) => combined({
 	id: `all(${relations.map((relation) => relation.id).join(", ")})`,
@@ -931,30 +1165,43 @@ const all = (...relations) => combined({
 	soft: relations.every((relation) => relation.soft),
 	softenable: true
 });
+const disjunctionOf = (conjunct, verdicts) => Match.value(decisionOf(combineAnyRelations(new CombineAnyRelations({
+	conjunct,
+	verdicts
+})))).pipe(Match.tag("AnyRelationHeld", (held) => Hold.make({
+	conjunct: held.conjunct,
+	inspected: held.inspected
+})), Match.tag("NoRelationHeld", (broken) => Break.make({
+	conjunct: broken.conjunct,
+	inspected: broken.inspected,
+	detail: broken.detail
+})), Match.exhaustive);
 const any = (...relations) => {
 	const id = `any(${relations.map((relation) => relation.id).join(", ")})`;
 	return relation({
 		id,
 		soft: false,
 		softenable: false,
-		evaluate: (graph) => {
-			const verdicts = relations.map((relation) => relation(graph));
-			const inspected = verdicts.flatMap((verdict) => verdict.inspected);
-			return verdicts.some(isHold$1) ? Hold.make({
-				conjunct: id,
-				inspected
-			}) : Break.make({
-				conjunct: id,
-				inspected,
-				detail: verdicts.map((verdict) => verdict.conjunct).join(", ")
-			});
-		}
+		evaluate: (graph) => disjunctionOf(id, relations.map((relation) => relation(graph)))
 	});
 };
 const REACH_BY_RELATION = {
 	child: childIdsOf,
 	descendant: descendantIdsOf
 };
+const placementVerdictOf = (conjunct, placed, reached, detail) => Match.value(decisionOf(judgeEdgePlacement(new JudgeEdgePlacement({
+	conjunct,
+	placed,
+	reached: [...reached],
+	detail
+})))).pipe(Match.tag("EdgePlacementHeld", (held) => Hold.make({
+	conjunct: held.conjunct,
+	inspected: held.inspected
+})), Match.tag("EdgePlacementBroken", (broken) => Break.make({
+	conjunct: broken.conjunct,
+	inspected: broken.inspected,
+	detail: broken.detail
+})), Match.exhaustive);
 const placementOf = (edge) => {
 	const id = `placement(${edge.relation}:${edge.parent.id},${edge.child.id})`;
 	return relation({
@@ -962,14 +1209,9 @@ const placementOf = (edge) => {
 		soft: false,
 		softenable: false,
 		evaluate: (graph) => {
-			const placed = matchedNodes(graph, edge.child);
+			const placed = inspectedOf(matchedNodes(graph, edge.child));
 			const reached = REACH_BY_RELATION[edge.relation](graph, matchedNodes(graph, edge.parent));
-			return verdictOf$1({
-				id,
-				inspected: inspectedOf(placed),
-				holds: placed.every((node) => reached.has(node.spanId)),
-				detail: `a ${edge.child.id} span is not a ${edge.relation} of any ${edge.parent.id} span`
-			});
+			return placementVerdictOf(id, placed, reached, `a ${edge.child.id} span is not a ${edge.relation} of any ${edge.parent.id} span`);
 		}
 	});
 };
@@ -986,44 +1228,87 @@ const fromTaxonomyImpl = (taxonomy, options) => combined({
 });
 const fromTaxonomy = dual(2, fromTaxonomyImpl);
 //#endregion
+//#region src/settle-remote-read.workflow.ts
+const SettleRemoteReadTypeId = Symbol.for("@systemfsoftware/trace-spec/SettleRemoteRead");
+const ObservedSpans = Schema.Struct({
+	spans: Schema.Array(SpanRecord),
+	addedAtMillis: Schema.Finite
+});
+var ReadSettled = class extends Schema.TaggedClass()("ReadSettled", { observation: ObservedSpans }) {
+	[SettleRemoteReadTypeId] = SettleRemoteReadTypeId;
+};
+var ReadAbsent = class extends Schema.TaggedClass()("ReadAbsent", { observation: ObservedSpans }) {
+	[SettleRemoteReadTypeId] = SettleRemoteReadTypeId;
+};
+var ReadUnfinished = class extends Schema.TaggedClass()("ReadUnfinished", { observation: ObservedSpans }) {
+	[SettleRemoteReadTypeId] = SettleRemoteReadTypeId;
+};
+var ReadStillGrowing = class extends Schema.TaggedClass()("ReadStillGrowing", { observation: ObservedSpans }) {
+	[SettleRemoteReadTypeId] = SettleRemoteReadTypeId;
+};
+const SettleRemoteReadDecision = Schema.Union([
+	ReadSettled,
+	ReadAbsent,
+	ReadUnfinished,
+	ReadStillGrowing
+]);
+var SettleRemoteRead = class extends Schema.TaggedClass()("SettleRemoteRead", {
+	observed: ObservedSpans,
+	read: Schema.Array(SpanRecord),
+	elapsedMillis: Schema.Finite,
+	settleMillis: Schema.Finite,
+	timeoutMillis: Schema.Finite
+}) {
+	static [Workflow.InstrumentationBrand] = {};
+};
+const sameId = (left, right) => left.spanId === right.spanId;
+const firstOfEachId = (read) => Array$1.dedupeWith(read, sameId);
+const freshOf = (observed, read) => Array$1.filter(firstOfEachId(read), (span) => Array$1.every(observed.spans, (seen) => seen.spanId !== span.spanId));
+const absorbed = (observed, read, elapsedMillis) => {
+	const fresh = freshOf(observed, read);
+	return Option.match(Array$1.head(fresh), {
+		onNone: () => observed,
+		onSome: () => ({
+			spans: [...observed.spans, ...fresh],
+			addedAtMillis: 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 settleRemoteRead = Workflow.make({
+	command: SettleRemoteRead,
+	decision: SettleRemoteReadDecision,
+	error: Schema.Never,
+	decide
+});
+//#endregion
 //#region src/RemoteObservation.ts
 var RemoteObservation_exports = /* @__PURE__ */ __exportAll({ layer: () => layer });
 const NEVER_READ = {
 	spans: [],
 	addedAtMillis: 0
 };
-const idOf = (span) => span.spanId;
-const sameId = (left, right) => left.spanId === right.spanId;
-const idsOf = (spans) => new Set(spans.map(idOf));
-const firstOfEachId = (read) => Array$1.dedupeWith(read, sameId);
-const freshOf = (settlement, read) => {
-	const known = idsOf(settlement.spans);
-	return firstOfEachId(read).filter((span) => !known.has(span.spanId));
-};
-const absorbed = (settlement, read, elapsedMillis) => {
-	const fresh = freshOf(settlement, read);
-	return fresh.length === 0 ? settlement : {
-		spans: [...settlement.spans, ...fresh],
-		addedAtMillis: elapsedMillis
-	};
-};
-const quietForLongEnough = (settlement, elapsedMillis, windows) => settlement.spans.length > 0 && elapsedMillis - settlement.addedAtMillis >= windows.settleMillis;
+const settlementOf = (command) => Result.match(settleRemoteRead(command), {
+	onFailure: (unreachable) => absurd(unreachable),
+	onSuccess: (decision) => decision
+});
 const pastDeadline = (elapsedMillis, windows) => elapsedMillis >= windows.timeoutMillis;
 const settledVerdict = (spans) => Option.some(Result.succeed(spans));
 const refusedVerdict = (refusal) => Option.some(Result.fail(refusal));
-const verdictOf = (settlement, elapsedMillis, windows) => Match.value({
-	quiet: quietForLongEnough(settlement, elapsedMillis, windows),
-	vacant: settlement.spans.length === 0,
-	late: pastDeadline(elapsedMillis, windows)
-}).pipe(Match.when({ quiet: true }, () => settledVerdict(settlement.spans)), Match.when({
-	vacant: true,
-	late: true
-}, () => refusedVerdict("absent")), Match.when({ late: true }, () => refusedVerdict("unfinished")), Match.orElse(() => Option.none()));
+const verdictOfOutcome = (outcome) => Match.value(outcome).pipe(Match.tag("ReadSettled", (settled) => settledVerdict(settled.observation.spans)), Match.tag("ReadAbsent", () => refusedVerdict("absent")), Match.tag("ReadUnfinished", () => refusedVerdict("unfinished")), Match.tag("ReadStillGrowing", () => Option.none()), Match.exhaustive);
 const settleStep = (settlement, read, elapsedMillis, windows) => {
-	const advanced = absorbed(settlement, read, elapsedMillis);
+	const outcome = settlementOf(new SettleRemoteRead({
+		observed: settlement,
+		read,
+		elapsedMillis,
+		settleMillis: windows.settleMillis,
+		timeoutMillis: windows.timeoutMillis
+	}));
 	return {
-		settlement: advanced,
-		verdict: verdictOf(advanced, elapsedMillis, windows)
+		settlement: outcome.observation,
+		verdict: verdictOfOutcome(outcome)
 	};
 };
 const lateRefusal = (settlement) => settlement.spans.length === 0 ? "absent" : "unfinished";
@@ -1147,6 +1432,17 @@ const HarnessFailure = Schema.Union([
 	TransportObservationError
 ]);
 //#endregion
+//#region src/StimulusFailure.schema.ts
+const firstLine = (text) => text.split("\n")[0] ?? "";
+var StimulusFailure = class extends Schema.TaggedError()("StimulusFailure", {
+	stimulus: Schema.String,
+	detail: Schema.String
+}) {
+	get message() {
+		return `The stimulus "${this.stimulus}" failed: ${firstLine(this.detail)}`;
+	}
+};
+//#endregion
 //#region src/TaskAnnounce.ts
 const forget = (annotation) => {
 	Promise.resolve(annotation);
@@ -1169,40 +1465,6 @@ const announceDump = (judged) => Option.match(dumpMessageOf(judged), {
 	onSome: (message) => record(message, "info")
 });
 //#endregion
-//#region src/Prop.ts
-const isHold = Schema.is(Hold);
-/**
-* The contract with its stimulus replaced by the function the property was handed: the impostor gate
-* swaps in a constant fake, so the judgement must reach the stimulus through the argument, never the
-* closure.
-*/
-const judgedOver = (contract, subject) => ({
-	...contract,
-	stimulus: subject
-});
-/**
-* The run must be the run of the generated input: a stimulus that ignores its input and answers with one
-* frozen run satisfies every relation about that run, so the input pin is what refutes it.
-*/
-const consumedInput = (judgment, input) => judgment.run.input === input;
-const predicateImpl = (title, contract, scenario, shared) => {
-	const provided = scenario.pipe(Layer.provideMerge(shared));
-	const checked = (subject, input) => judge(judgedOver(contract, subject), input, { dumpName: title }).pipe(Effect.tap(announceDump), Effect.map((judgment) => isHold(judgment.verdict) && consumedInput(judgment, input)), Effect.provide(Layer.fresh(provided)));
-	return (subject, input) => checked(subject, input);
-};
-const predicate = dual(4, predicateImpl);
-//#endregion
-//#region src/StimulusFailure.schema.ts
-const firstLine = (text) => text.split("\n")[0] ?? "";
-var StimulusFailure = class extends Schema.TaggedError()("StimulusFailure", {
-	stimulus: Schema.String,
-	detail: Schema.String
-}) {
-	get message() {
-		return `The stimulus "${this.stimulus}" failed: ${firstLine(this.detail)}`;
-	}
-};
-//#endregion
 //#region src/Suite.ts
 var Suite_exports = /* @__PURE__ */ __exportAll({
 	StimulusFailure: () => StimulusFailure,
@@ -1230,6 +1492,17 @@ const caseFailureOf = (stimulus, salt) => (failure) => isHarnessFailure(failure)
 	detail: `${Cause.pretty(Cause.fail(failure))}\nrandom salt: ${salt}`
 });
 const caseBody = (expect, contract, input, salt) => judge(contract, input).pipe(Effect.tap(announceDump), Effect.flatMap((judgment) => verdictCheck(contract, expect, judgment)), Effect.mapError(caseFailureOf(contract.stimulus.name, salt)));
+const isHold = Schema.is(Hold);
+const judgedOver = (contract, subject) => ({
+	...contract,
+	stimulus: subject
+});
+const consumedInput = (judgment, input) => judgment.run.input === input;
+const casePredicate = (title, contract, scenario, shared) => {
+	const provided = scenario.pipe(Layer.provideMerge(shared));
+	const checked = (subject, input) => judge(judgedOver(contract, subject), input, { dumpName: title }).pipe(Effect.tap(announceDump), Effect.map((judgment) => isHold(judgment.verdict) && consumedInput(judgment, input)), Effect.provide(Layer.fresh(provided)));
+	return (subject, input) => checked(subject, input);
+};
 const caseTools = (register, propIt, scenario, shared) => {
 	const Case = (name, contract, input) => {
 		const salt = saltOf();
@@ -1240,7 +1513,7 @@ const caseTools = (register, propIt, scenario, shared) => {
 		propIt.effect.prop(name, {
 			of: [arbitrary],
 			subject: contract.stimulus
-		}, (subject, values) => predicate(name, contract, scenario, shared)(subject, values[0]).pipe(Random.withSeed(salt)));
+		}, (subject, values) => casePredicate(name, contract, scenario, shared)(subject, values[0]).pipe(Random.withSeed(salt)));
 	};
 	return { Case };
 };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@systemfsoftware/trace-spec",
   "license": "Apache-2.0",
-  "version": "0.5.1",
+  "version": "0.5.2",
   "author": "Ryan Lee <drdgvhbh@gmail.com>",
   "repository": {
     "type": "git",
@@ -39,18 +39,25 @@
     "@opentelemetry/sdk-trace-base": "^2",
     "@opentelemetry/semantic-conventions": "^1.33",
     "@systemfsoftware/effect-cell-types": "^11.0.0",
-    "@systemfsoftware/effect-spec-runtime": "^0.3.1",
+    "@systemfsoftware/effect-spec-runtime": "^0.3.2",
     "@systemfsoftware/trace-taxonomy": "^0.0.2"
   },
   "devDependencies": {
     "@effect/platform-node": "4.0.0-rc.117",
     "@systemfsoftware/arethetypeswrong-cli": "^4.2.0",
     "@systemfsoftware/conformance-spec": "^0.2.0",
-    "@systemfsoftware/effect-gherkin-spec": "^6.0.0",
-    "@systemfsoftware/oxlint-config-recommended": "^3.2.0",
+    "@systemfsoftware/effect-gherkin-spec": "^6.0.1",
+    "@systemfsoftware/oxlint-config-recommended": "^3.3.0",
+    "@systemfsoftware/stryker-config": "^0.1.0",
+    "@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": "^0.2.0",
+    "@systemfsoftware/vitest": "^0.3.0",
     "@systemfsoftware/vitest-config": "^0.1.0",
     "@types/node": "^26",
     "effect": "4.0.0-rc.117",
@@ -61,7 +68,7 @@
     "vitest": "^5"
   },
   "peerDependencies": {
-    "@systemfsoftware/vitest": "^0.2.0",
+    "@systemfsoftware/vitest": "^0.3.0",
     "effect": "4.0.0-rc.117",
     "vitest": "^5"
   },
@@ -74,6 +81,8 @@
     "build": "tsdown -l warn",
     "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 ."