@systemfsoftware/trace-spec 0.2.1 → 0.3.0

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # @systemfsoftware/trace-spec
 
+## 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

package/dist/index.d.ts

@@ -3,6 +3,7 @@ import { Pipeable } from "effect/Pipeable";
 import { Span, Taxonomy } from "@systemfsoftware/trace-taxonomy";
 import * as HttpClient from "effect/unstable/http/HttpClient";
 import * as OtelTracer from "@effect/opentelemetry/OtelTracer";
+import { Blueprint, Handle } from "@systemfsoftware/effect-cell-types";
 import { BasicTracerProvider, InMemorySpanExporter } from "@opentelemetry/sdk-trace-base";
 import { Suite } from "@systemfsoftware/effect-spec-runtime";
 import * as Scope from "effect/Scope";
@@ -320,7 +321,7 @@ declare const check: {
   <Input, Output, E, R>(self: Contract<Input, Output, E, R>, input: Input, options?: CheckOptions): Effect.Effect<Judgment<Input, Output>, CheckFailure<E>, Services<R>>;
 };
 declare namespace RemoteObservation_d_exports {
-  export { Options, TraceSource, layer };
+  export { Options, TraceSource, layer$1 as layer };
 }
 /**
  * The cadence of the poll, the quiet window the observed span set must hold
@@ -348,7 +349,7 @@ type TraceSource<R> = (traceId: string) => Effect.Effect<ReadonlyArray<SpanRecor
  * the source requires (`Scope.Scope` is supplied by the layer machinery, as
  * every Effect layer constructor scopes it away).
  */
-declare const layer: {
+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>>;
 };
@@ -370,15 +371,19 @@ declare namespace observation_window_handle_d_exports {
 }
 declare const TypeId$2: unique symbol;
 type TypeId$2 = typeof TypeId$2;
-declare const ExporterId: unique symbol;
-declare const ProviderId: unique symbol;
-interface ObservationWindow extends Pipeable {
-  readonly [TypeId$2]: typeof TypeId$2;
-  readonly [ExporterId]: InMemorySpanExporter;
-  readonly [ProviderId]: BasicTracerProvider;
+declare const ObservationWindow: Handle.Definition<typeof TypeId$2, {
   readonly serviceName: string;
-}
-declare const isObservationWindow: (u: unknown) => u is ObservationWindow;
+}, {
+  readonly exporter: InMemorySpanExporter;
+  readonly provider: BasicTracerProvider;
+}, never>;
+type ObservationWindow = Handle.Of<typeof ObservationWindow>;
+declare const isObservationWindow: (u: unknown) => u is Handle.Handle<typeof TypeId$2, {
+  readonly serviceName: string;
+}, {
+  readonly exporter: InMemorySpanExporter;
+  readonly provider: BasicTracerProvider;
+}, never>;
 declare const make$2: (spec: ObservationWindowSpec) => ObservationWindow;
 declare const shutdown: (self: ObservationWindow) => Effect.Effect<void>;
 declare const collect: {
@@ -386,18 +391,19 @@ declare const collect: {
   (self: ObservationWindow, traceId: string): Effect.Effect<ReadonlyArray<SpanRecord>, EmptyObservationError>;
 };
 declare const context: (self: ObservationWindow) => Context.Context<Observation | OtelTracer.OtelTracerProvider>;
-declare namespace observation_window_resource_d_exports {
-  export { ObservationWindow, ObservationWindowResource, ObservationWindowSpec, TypeId$2 as ObservationWindowTypeId, TypeId$1 as TypeId, collect, isObservationWindow, make$1 as make };
+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;
-interface ObservationWindowResource extends Pipeable {
-  readonly [TypeId$1]: typeof TypeId$1;
-  readonly spec: ObservationWindowSpec;
-  readonly scoped: Effect.Effect<ObservationWindow, never, Scope.Scope>;
-  readonly layer: Layer.Layer<Observation | OtelTracer.OtelTracer>;
-}
-declare const make$1: (serviceName: string) => ObservationWindowResource;
+declare const scoped: (spec: ObservationWindowSpec) => Effect.Effect<ObservationWindow, never, Scope.Scope>;
+declare const layer: (spec: ObservationWindowSpec) => Layer.Layer<Observation | OtelTracer.OtelTracer>;
+declare const ObservationWindows: Blueprint.Definition<typeof TypeId$1, ObservationWindowSpec, Blueprint.Derived<ObservationWindowSpec, {}, {
+  readonly scoped: typeof scoped;
+  readonly layer: typeof layer;
+}>, ObservationWindowSpec>;
+type ObservationWindowBlueprint = Blueprint.Of<typeof ObservationWindows>;
+declare const make$1: (serviceName: string) => ObservationWindowBlueprint;
 //#endregion
 //#region src/HarnessFailure.schema.d.ts
 declare const HarnessFailure: Schema.Union<readonly [typeof ContractDecodeError, typeof EmptyObservationError, typeof IncompleteObservationError, typeof TransportObservationError, typeof TraceDisparityError]>;
@@ -447,4 +453,4 @@ declare const withScenarioLayer: {
 };
 declare const make: (bindings: Suite.Bindings) => (name: string) => Declared;
 //#endregion
-export { Contract_d_exports as Contract, Graph_d_exports as Graph, Observation_service_d_exports as Observation, observation_window_resource_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 };
+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

@@ -1,4 +1,5 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { recordAssertion } from "@effect/vitest";
 import { Array as Array$1, Cause, Clock, Context, Duration, Effect, Encoding, Equal, FileSystem, Layer, Match, Option, Predicate, Ref, Result, Schema, SchemaGetter, SchemaTransformation } from "effect";
 import { dual } from "effect/Function";
 import { Prototype } from "effect/Pipeable";
@@ -9,6 +10,7 @@ import * as HttpClientRequest from "effect/unstable/http/HttpClientRequest";
 import * as HttpClientResponse from "effect/unstable/http/HttpClientResponse";
 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, InMemorySpanExporter, SimpleSpanProcessor } from "@opentelemetry/sdk-trace-base";
 import { Suite, TaskRef } from "@systemfsoftware/effect-spec-runtime";
@@ -326,7 +328,7 @@ const refuseBreak = (relationId, judgment) => Match.value(judgment.verdict).pipe
 	breaks: [breach],
 	dumpPath: judgment.dumpPath
 }))), Match.tag("Hold", () => Effect.succeed(judgment)), Match.exhaustive);
-const checkDual = (self, input, options) => Effect.flatMap(judgeDual(self, input, options), (judgment) => refuseBreak(self.relation.id, judgment));
+const checkDual = (self, input, options) => Effect.flatMap(judgeDual(self, input, options), (judgment) => Effect.andThen(Effect.sync(recordAssertion), refuseBreak(self.relation.id, judgment)));
 const check = dual((args) => isContract(args[0]), checkDual);
 //#endregion
 //#region src/drivers/tempo-trace.schema.ts
@@ -544,24 +546,20 @@ Schema.encodeEffect(HexId);
 //#endregion
 //#region src/observation-window.handle.ts
 const TypeId$2 = Symbol.for("~systemfsoftware/trace-spec/ObservationWindow");
-const ExporterId = Symbol.for("~systemfsoftware/trace-spec/ObservationWindow/exporter");
-const ProviderId = Symbol.for("~systemfsoftware/trace-spec/ObservationWindow/provider");
-const isObservationWindow = (u) => Predicate.hasProperty(u, TypeId$2);
+const ObservationWindow = Handle.make()(TypeId$2);
+const isObservationWindow = ObservationWindow.is;
 const make$3 = (spec) => {
 	const exporter = new InMemorySpanExporter();
 	const provider = new BasicTracerProvider({
 		sampler: new AlwaysOnSampler(),
 		spanProcessors: [new SimpleSpanProcessor(exporter)]
 	});
-	return {
-		[TypeId$2]: TypeId$2,
-		[ExporterId]: exporter,
-		[ProviderId]: provider,
-		serviceName: spec.serviceName,
-		...Prototype
-	};
+	return ObservationWindow.make({ serviceName: spec.serviceName }, {
+		exporter,
+		provider
+	});
 };
-const shutdown = (self) => Effect.promise(() => self[ProviderId].shutdown());
+const shutdown = (self) => Effect.promise(() => ObservationWindow.slot(self).provider.shutdown());
 const SCALAR_TYPES = {
 	string: true,
 	number: true,
@@ -616,39 +614,36 @@ const emptyObservation = (traceId) => new EmptyObservationError({
 	traceId,
 	detail: "the observation window closed with no span carrying the stimulated trace id"
 });
-const recordsOf = (self, traceId) => self[ExporterId].getFinishedSpans().filter((span) => span.spanContext().traceId === traceId).map(spanRecordOf);
+const recordsOf = (self, traceId) => ObservationWindow.slot(self).exporter.getFinishedSpans().filter((span) => span.spanContext().traceId === traceId).map(spanRecordOf);
 const collect = dual(2, (self, traceId) => Effect.suspend(() => {
 	const records = recordsOf(self, traceId);
 	return records.length > 0 ? Effect.succeed(records) : Effect.fail(emptyObservation(traceId));
 }));
-const context = (self) => Context.make(Observation, { collect: (traceId) => collect(self, traceId) }).pipe(Context.add(OtelTracer.OtelTracerProvider, self[ProviderId]));
+const context = (self) => Context.make(Observation, { collect: (traceId) => collect(self, traceId) }).pipe(Context.add(OtelTracer.OtelTracerProvider, ObservationWindow.slot(self).provider));
 //#endregion
 //#region src/ObservationWindowSpec.schema.ts
 var ObservationWindowSpec = class extends Schema.Class("ObservationWindowSpec")({ serviceName: Schema.NonEmptyString }) {};
 //#endregion
-//#region src/observation-window.resource.ts
-var observation_window_resource_exports = /* @__PURE__ */ __exportAll({
+//#region src/observation-window.blueprint.ts
+var observation_window_blueprint_exports = /* @__PURE__ */ __exportAll({
 	ObservationWindowSpec: () => ObservationWindowSpec,
 	ObservationWindowTypeId: () => TypeId$2,
+	TypeId: () => TypeId$1,
 	collect: () => collect,
 	isObservationWindow: () => isObservationWindow,
 	make: () => make$2
 });
-const TypeId$1 = Symbol.for("~systemfsoftware/trace-spec/ObservationWindowResource");
+const TypeId$1 = Symbol.for("~systemfsoftware/trace-spec/ObservationWindowBlueprint");
 const scoped = (spec) => Effect.acquireRelease(Effect.sync(() => make$3(spec)), shutdown);
 const layer$1 = (spec) => OtelTracer.layer.pipe(Layer.provideMerge(OtelResource.layer({ serviceName: spec.serviceName })), Layer.provideMerge(Layer.effectContext(Effect.map(scoped(spec), context))));
-const makeProto = (spec) => ({
-	[TypeId$1]: TypeId$1,
-	spec,
-	get scoped() {
-		return scoped(spec);
-	},
-	get layer() {
-		return layer$1(spec);
-	},
-	...Prototype
+const ObservationWindows = Blueprint.make()(TypeId$1).steps({
+	steps: {},
+	targets: {
+		scoped,
+		layer: layer$1
+	}
 });
-const make$2 = (serviceName) => makeProto(new ObservationWindowSpec({ serviceName }));
+const make$2 = (serviceName) => ObservationWindows.of(new ObservationWindowSpec({ serviceName }));
 //#endregion
 //#region src/Rel.ts
 var Rel_exports = /* @__PURE__ */ __exportAll({
@@ -1087,18 +1082,35 @@ const HarnessFailure = Schema.Union([
 //#region src/Prop.ts
 const isHold = Schema.is(Hold);
 const isBreak = Schema.is(Break);
-const annotate = (context, message) => Option.match(Option.flatMap(Option.fromNullishOr(context), (task) => Option.fromNullishOr(task.annotate)), {
-	onNone: () => Effect.void,
-	onSome: (record) => Effect.promise(() => Promise.resolve(record(message, "info")))
+const annotate = (message) => Effect.gen(function* () {
+	const task = yield* TaskRef.RawVitestTaskRef;
+	return yield* Option.match(Option.fromNullishOr(task?.annotate), {
+		onNone: () => Effect.void,
+		onSome: (record) => Effect.promise(() => Promise.resolve(record(message, "info")))
+	});
 });
 const dumpMessageOf = (verdict, dumpPath) => Option.map(Option.flatMap(Option.liftPredicate(verdict, isBreak), () => Option.fromNullishOr(dumpPath)), (path) => `trace contract failed; observed graph dumped to ${path}`);
-const announce = (context, verdict, dumpPath) => Option.match(dumpMessageOf(verdict, dumpPath), {
+const announce = (verdict, dumpPath) => Option.match(dumpMessageOf(verdict, dumpPath), {
 	onNone: () => Effect.void,
-	onSome: (message) => annotate(context, message)
+	onSome: (message) => annotate(message)
+});
+/**
+* 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) => {
-	const checked = (input, context) => judge(contract, input, { dumpName: title }).pipe(Effect.tap((judgment) => announce(context, judgment.verdict, judgment.dumpPath)), Effect.map((judgment) => isHold(judgment.verdict)), Effect.provide(Layer.fresh(scenario)));
-	return (input, context) => checked(input, context);
+	const checked = (subject, input) => judge(judgedOver(contract, subject), input, { dumpName: title }).pipe(Effect.tap((judgment) => announce(judgment.verdict, judgment.dumpPath)), Effect.map((judgment) => isHold(judgment.verdict) && consumedInput(judgment, input)), Effect.provide(Layer.fresh(scenario)));
+	return (subject, input) => checked(subject, input);
 };
 const predicate = dual(3, predicateImpl);
 //#endregion
@@ -1146,7 +1158,10 @@ const caseBody = (contract, input) => check(contract, input).pipe(Effect.catchIf
 const caseTools = (register, propIt, scenario) => {
 	const Case = (name, contract, input) => register(name, caseBody(contract, input), "run");
 	Case.prop = (name, contract, arbitrary) => {
-		propIt.effect.prop(name, [arbitrary], (values, context) => predicate(name, contract, scenario)(values[0], context));
+		propIt.effect.prop(name, {
+			of: [arbitrary],
+			subject: contract.stimulus
+		}, (subject, values) => predicate(name, contract, scenario)(subject, values[0]));
 	};
 	return { Case };
 };
@@ -1181,4 +1196,4 @@ const make = (bindings) => (name) => ({
 	...Prototype
 });
 //#endregion
-export { Contract_exports as Contract, Graph_exports as Graph, Observation_service_exports as Observation, observation_window_resource_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 };
+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": "0.2.1",
+  "version": "0.3.0",
   "author": "Ryan Lee <drdgvhbh@gmail.com>",
   "repository": {
     "type": "git",
@@ -38,15 +38,16 @@
     "@opentelemetry/resources": "^2",
     "@opentelemetry/sdk-trace-base": "^2",
     "@opentelemetry/semantic-conventions": "^1.33",
-    "@systemfsoftware/effect-spec-runtime": "^0.1.1",
+    "@systemfsoftware/effect-cell-types": "^10.2.0",
+    "@systemfsoftware/effect-spec-runtime": "^0.2.0",
     "@systemfsoftware/trace-taxonomy": "^0.0.1"
   },
   "devDependencies": {
     "@effect/platform-node": "4.0.0-rc.117",
-    "@effect/vitest": "4.0.0-rc.117",
+    "@effect/vitest": "npm:@systemfsoftware/vitest@0.0.0",
     "@systemfsoftware/arethetypeswrong-cli": "^4.2.0",
-    "@systemfsoftware/effect-gherkin-spec": "^4.3.1",
-    "@systemfsoftware/oxlint-config-recommended": "^2.0.2",
+    "@systemfsoftware/effect-gherkin-spec": "^4.4.0",
+    "@systemfsoftware/oxlint-config-recommended": "^3.0.0",
     "@systemfsoftware/tsconfig": "^2.0.1",
     "@systemfsoftware/tsdown-config": "^0.1.0",
     "@systemfsoftware/vitest-config": "^0.1.0",
@@ -59,7 +60,7 @@
     "vitest": "^5"
   },
   "peerDependencies": {
-    "@effect/vitest": "4.0.0-rc.117",
+    "@effect/vitest": "npm:@systemfsoftware/vitest@*",
     "effect": "4.0.0-rc.117",
     "vitest": "^5"
   },