@systemfsoftware/trace-spec 0.0.0 → 0.1.0

package/CHANGELOG.md

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

package/dist/index.d.ts

@@ -104,9 +104,18 @@ type TraceGraph = typeof TraceGraph.Type;
 declare namespace Graph_d_exports {
   export { AttributeValue, Attributes, GraphNode, SpanEvent, SpanLink, SpanRecord, Status, TraceGraph, byId, children, decode, descendants };
 }
-declare const byId: (graph: TraceGraph, spec: Span.Span) => ReadonlyArray<GraphNode>;
-declare const children: (graph: TraceGraph, node: GraphNode) => ReadonlyArray<GraphNode>;
-declare const descendants: (graph: TraceGraph, node: GraphNode) => ReadonlyArray<GraphNode>;
+declare const byId: {
+  (spec: Span.Span): (graph: TraceGraph) => ReadonlyArray<GraphNode>;
+  (graph: TraceGraph, spec: Span.Span): ReadonlyArray<GraphNode>;
+};
+declare const children: {
+  (node: GraphNode): (graph: TraceGraph) => ReadonlyArray<GraphNode>;
+  (graph: TraceGraph, node: GraphNode): ReadonlyArray<GraphNode>;
+};
+declare const descendants: {
+  (node: GraphNode): (graph: TraceGraph) => ReadonlyArray<GraphNode>;
+  (graph: TraceGraph, node: GraphNode): ReadonlyArray<GraphNode>;
+};
 /**
  * Decodes the recorded spans of one trace against a taxonomy, purely: a declared span
  * whose required attributes do not decode refuses with {@link ContractDecodeError}
@@ -114,7 +123,10 @@ declare const descendants: (graph: TraceGraph, node: GraphNode) => ReadonlyArray
  * the graph as recorded. Failure is a `Result`, so the phase that reads the trace cannot
  * fail the pipeline by accident.
  */
-declare const decode: (traceId: string, spans: ReadonlyArray<SpanRecord>, taxonomy: Taxonomy.Taxonomy) => Result.Result<TraceGraph, ContractDecodeError>;
+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>;
+};
 declare namespace Observation_service_d_exports {
   export { Collector, EmptyObservationError, Observation };
 }
@@ -156,22 +168,54 @@ interface Relation {
 declare const exists: <S extends Span.Span>(spec: S) => Relation;
 declare const absent: <S extends Span.Span>(spec: S) => Relation;
 declare const unique: <S extends Span.Span>(spec: S) => Relation;
-declare const child: (parent: Span.Span, childSpan: Span.Span) => Relation;
-declare const descendant: (parent: Span.Span, childSpan: Span.Span) => Relation;
-declare const order: (before: Span.Span, after: Span.Span) => Relation;
-declare const status: (spec: Span.Span, expected: Status) => Relation;
-declare const errorType: (spec: Span.Span, expected: string) => Relation;
-declare const attrs: <S extends Span.Span>(spec: S, partial: Partial<Span.AttrsOf<S>>) => Relation;
-declare const durationLessThan: (spec: Span.Span, millis: number) => Relation;
-declare const event: (spec: Span.Span, name: string) => Relation;
-declare const forall: (spec: Span.Span, predicate: (node: GraphNode) => boolean, detail: string) => Relation;
+declare const child: {
+  (childSpan: Span.Span): (parent: Span.Span) => Relation;
+  (parent: Span.Span, childSpan: Span.Span): Relation;
+};
+declare const descendant: {
+  (childSpan: Span.Span): (parent: Span.Span) => Relation;
+  (parent: Span.Span, childSpan: Span.Span): Relation;
+};
+declare const order: {
+  (after: Span.Span): (before: Span.Span) => Relation;
+  (before: Span.Span, after: Span.Span): Relation;
+};
+declare const status: {
+  (expected: Status): (spec: Span.Span) => Relation;
+  (spec: Span.Span, expected: Status): Relation;
+};
+declare const errorType: {
+  (expected: string): (spec: Span.Span) => Relation;
+  (spec: Span.Span, expected: string): Relation;
+};
+declare const attrs: {
+  <S extends Span.Span>(partial: Partial<Span.AttrsOf<S>>): (spec: S) => Relation;
+  <S extends Span.Span>(spec: S, partial: Partial<Span.AttrsOf<S>>): Relation;
+};
+declare const durationLessThan: {
+  (millis: number): (spec: Span.Span) => Relation;
+  (spec: Span.Span, millis: number): Relation;
+};
+declare const event: {
+  (name: string): (spec: Span.Span) => Relation;
+  (spec: Span.Span, name: string): Relation;
+};
+declare const forall: {
+  (predicate: (node: GraphNode) => boolean, detail: string): (spec: Span.Span) => Relation;
+  (spec: Span.Span, predicate: (node: GraphNode) => boolean, detail: string): Relation;
+};
 declare const soft: (self: Relation) => Relation;
 declare const not: (self: Relation) => Relation;
 declare const all: (...relations: ReadonlyArray<Relation>) => Relation;
 declare const any: (...relations: ReadonlyArray<Relation>) => Relation;
-declare const fromTaxonomy: (taxonomy: Taxonomy.Taxonomy, options: {
-  readonly path: string;
-}) => Relation;
+declare const fromTaxonomy: {
+  (options: {
+    readonly path: string;
+  }): (taxonomy: Taxonomy.Taxonomy) => Relation;
+  (taxonomy: Taxonomy.Taxonomy, options: {
+    readonly path: string;
+  }): Relation;
+};
 declare namespace Stimulus_d_exports {
   export { Run, Stimulus, TraceContext, make$3 as make, traceContext };
 }

package/dist/index.mjs

@@ -61,15 +61,16 @@ const renderNode = (spans, node, depth) => {
 		...childrenOf(spans, node.spanId).map((child) => renderNode(spans, child, depth + 1))
 	]].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 = (observed, report) => [
+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`;
 /**
@@ -156,12 +157,15 @@ var Graph_exports = /* @__PURE__ */ __exportAll({
 	decode: () => decode,
 	descendants: () => descendants
 });
-const byId = (graph, spec) => graph.nodes.filter((node) => node.name === spec.name);
-const children = (graph, node) => graph.nodes.filter((candidate) => candidate.parentSpanId === node.spanId);
-const descendants = (graph, node) => {
+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);
+const children = dual(2, childrenImpl);
+const descendantsImpl = (graph, node) => {
 	const direct = children(graph, node);
 	return [...direct, ...direct.flatMap((child) => descendants(graph, child))];
 };
+const descendants = dual(2, descendantsImpl);
 const indexDeclarations = (taxonomy) => new Map(taxonomy.spans.map((span) => [span.name, span]));
 const keyOfPath = (path) => {
 	const last = path.at(-1);
@@ -204,6 +208,10 @@ const graphOf = (traceId, nodes) => ({
 	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));
+};
 /**
 * Decodes the recorded spans of one trace against a taxonomy, purely: a declared span
 * whose required attributes do not decode refuses with {@link ContractDecodeError}
@@ -211,10 +219,7 @@ const graphOf = (traceId, nodes) => ({
 * the graph as recorded. Failure is a `Result`, so the phase that reads the trace cannot
 * fail the pipeline by accident.
 */
-const decode = (traceId, spans, taxonomy) => {
-	const declarations = indexDeclarations(taxonomy);
-	return Result.map(Result.all(spans.map((record) => declaredNodeOf(record, declarations))), (nodes) => graphOf(traceId, nodes));
-};
+const decode = dual(3, decodeImpl);
 //#endregion
 //#region src/Observation.service.ts
 var Observation_service_exports = /* @__PURE__ */ __exportAll({
@@ -497,65 +502,73 @@ const reachedUnder = (graph, parent, childSpan, reach) => {
 	const reached = reach(graph, matchedNodes(graph, parent));
 	return matchedNodes(graph, childSpan).some((node) => reached.has(node.spanId));
 };
-const child = (parent, childSpan) => declared({
+const childImpl = (parent, childSpan) => declared({
 	id: `child(${parent.id},${childSpan.id})`,
 	spans: [parent, childSpan],
 	softenable: true,
 	detail: `no ${childSpan.id} span is a direct child of a ${parent.id} span`,
 	holds: (graph) => reachedUnder(graph, parent, childSpan, childIdsOf)
 });
-const descendant = (parent, childSpan) => declared({
+const child = dual(2, childImpl);
+const descendantImpl = (parent, childSpan) => declared({
 	id: `descendant(${parent.id},${childSpan.id})`,
 	spans: [parent, childSpan],
 	softenable: true,
 	detail: `no ${childSpan.id} span descends from a ${parent.id} span`,
 	holds: (graph) => reachedUnder(graph, parent, childSpan, descendantIdsOf)
 });
-const order = (before, after) => declared({
+const descendant = dual(2, descendantImpl);
+const orderImpl = (before, after) => declared({
 	id: `order(${before.id},${after.id})`,
 	spans: [before, after],
 	softenable: true,
 	detail: `a ${after.id} span starts before every ${before.id} span`,
 	holds: (graph) => matchedAll(matchedNodes(graph, after), (node) => startsAfterSome(matchedNodes(graph, before), node))
 });
-const status = (spec, expected) => declared({
+const order = dual(2, orderImpl);
+const statusImpl = (spec, expected) => declared({
 	id: `status(${spec.id},${expected})`,
 	spans: [spec],
 	softenable: true,
 	detail: `a ${spec.id} span is not ${expected}`,
 	holds: holdsEveryOf(spec, (node) => node.status === expected)
 });
-const errorType = (spec, expected) => declared({
+const status = dual(2, statusImpl);
+const errorTypeImpl = (spec, expected) => declared({
 	id: `errorType(${spec.id},${expected})`,
 	spans: [spec],
 	softenable: true,
 	detail: `a ${spec.id} span carries a different error.type`,
 	holds: holdsEveryOf(spec, (node) => node.errorType === expected)
 });
+const errorType = dual(2, errorTypeImpl);
 const partialMatches = (attributes, partial) => Object.entries(partial).filter(([, value]) => value !== void 0).every(([key, value]) => Equal.equals(attributes[key], value));
-const attrs = (spec, partial) => declared({
+const attrsImpl = (spec, partial) => declared({
 	id: `attrs(${spec.id})`,
 	spans: [spec],
 	softenable: true,
 	detail: `a ${spec.id} span carries a different declared attribute`,
 	holds: holdsEveryOf(spec, (node) => partialMatches(node.attrs, partial))
 });
-const durationLessThan = (spec, millis) => declared({
+const attrs = dual(2, attrsImpl);
+const durationLessThanImpl = (spec, millis) => declared({
 	id: `durationLessThan(${spec.id},${millis})`,
 	spans: [spec],
 	softenable: true,
 	detail: `a ${spec.id} span exceeded ${millis}ms`,
 	holds: holdsEveryOf(spec, (node) => node.durationMillis < millis)
 });
+const durationLessThan = dual(2, durationLessThanImpl);
 const carriesEvent = (name) => (node) => node.events.some((event) => event.name === name);
-const event = (spec, name) => declared({
+const eventImpl = (spec, name) => declared({
 	id: `event(${spec.id},${name})`,
 	spans: [spec],
 	softenable: true,
 	detail: `a ${spec.id} span carries no ${name} event`,
 	holds: holdsEveryOf(spec, carriesEvent(name))
 });
-const forall = (spec, predicate, detail) => {
+const event = dual(2, eventImpl);
+const forallImpl = (spec, predicate, detail) => {
 	const id = `forall(${spec.id})`;
 	return relation({
 		id,
@@ -572,6 +585,7 @@ const forall = (spec, predicate, detail) => {
 		}
 	});
 };
+const forall = dual(3, forallImpl);
 const soft = (self) => self.softenable ? relation({
 	id: self.id,
 	soft: true,
@@ -667,12 +681,13 @@ const forbidsAt = (entry, path) => Option.match(entry.unless, {
 	onSome: (tag) => tag !== path
 });
 const forbiddenOn = (path) => (entry) => forbidsAt(entry, path) ? [absent(entry.span)] : [];
-const fromTaxonomy = (taxonomy, options) => combined({
+const fromTaxonomyImpl = (taxonomy, options) => combined({
 	id: `fromTaxonomy(${taxonomy.id},${options.path})`,
 	relations: [...taxonomy.edges.map(placementOf), ...taxonomy.forbidden.flatMap(forbiddenOn(options.path))],
 	soft: false,
 	softenable: false
 });
+const fromTaxonomy = dual(2, fromTaxonomyImpl);
 //#endregion
 //#region src/Stimulus.ts
 var Stimulus_exports = /* @__PURE__ */ __exportAll({
@@ -724,19 +739,11 @@ const announce = (context, verdict, dumpPath) => Option.match(dumpMessageOf(verd
 	onNone: () => Effect.void,
 	onSome: (message) => annotate(context, message)
 });
-/**
-* The generated-case predicate for one case: a factory that runs the contract's cell with
-* the dump named after the case — so every failing draw overwrites one file and the last
-* failing draw is the shrunk counterexample the runner reports — and answers the verdict as
-* the boolean: `true` while the relation held, `false` on a break, falsifying the property.
-* Only infrastructure refusals — a failing behaviour, an undecodable span, an empty
-* observation — stay on the error channel. The scenario layer is built fresh per draw, so
-* each draw owns its observation window.
-*/
-function predicate(title, contract, scenario) {
+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 predicate = dual(3, predicateImpl);
 //#endregion
 //#region src/StimulusFailure.schema.ts
 var StimulusFailure = class extends Schema.TaggedError()("StimulusFailure", {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@systemfsoftware/trace-spec",
   "license": "Apache-2.0",
-  "version": "0.0.0",
+  "version": "0.1.0",
   "author": "Ryan Lee <drdgvhbh@gmail.com>",
   "repository": {
     "type": "git",
@@ -38,25 +38,25 @@
     "@opentelemetry/resources": "^2",
     "@opentelemetry/sdk-trace-base": "^2",
     "@opentelemetry/semantic-conventions": "^1.33",
-    "@systemfsoftware/trace-taxonomy": "^0.0.0",
-    "@systemfsoftware/effect-spec-runtime": "^0.0.0"
+    "@systemfsoftware/effect-spec-runtime": "^0.1.0",
+    "@systemfsoftware/trace-taxonomy": "^0.0.0"
   },
   "devDependencies": {
     "@effect/platform-node": "4.0.0-rc.116",
     "@effect/vitest": "4.0.0-rc.116",
     "@systemfsoftware/arethetypeswrong-cli": "^4.2.0",
+    "@systemfsoftware/effect-gherkin-spec": "^4.3.0",
+    "@systemfsoftware/oxlint-config-recommended": "^2.0.0",
+    "@systemfsoftware/tsconfig": "^2.0.0",
+    "@systemfsoftware/tsdown-config": "^0.1.0",
+    "@systemfsoftware/vitest-config": "^0.1.0",
     "@types/node": "^26",
     "effect": "4.0.0-rc.116",
     "oxlint": "~1.82.0",
     "rimraf": "^6.1.3",
     "tsdown": "^0.23.0",
     "tstyche": "^7.2.5",
-    "vitest": "^5",
-    "@systemfsoftware/effect-gherkin-spec": "^4.2.3",
-    "@systemfsoftware/oxlint-config-recommended": "^1.1.1",
-    "@systemfsoftware/tsconfig": "^1.3.6",
-    "@systemfsoftware/tsdown-config": "^0.1.0",
-    "@systemfsoftware/vitest-config": "^0.1.0"
+    "vitest": "^5"
   },
   "peerDependencies": {
     "@effect/vitest": "4.0.0-rc.116",
@@ -69,7 +69,7 @@
   "scripts": {
     "clean": "rimraf dist",
     "build": "tsdown -l warn",
-    "typecheck": "tsc --noEmit --incremental",
+    "typecheck": "tsc -b",
     "test": "vitest run",
     "test:types": "TSTYCHE_TYPESCRIPT_MODULE=tstyche-typescript tstyche",
     "lint": "f=${OXLINT_FORMAT:-${AGENT:+agent}}; oxlint . --format=${f:-default}",