laymos 0.0.1 → 0.0.2

package/dist/story/schema/story-report-schema.d.ts

@@ -0,0 +1,408 @@
+import { Schema } from 'effect';
+import { RecordedFlowSchema } from '@pkishorez/effect-tracer/flow';
+export { RecordedFlowSchema };
+export type JsonValue = string | number | boolean | null | readonly JsonValue[] | {
+    readonly [key: string]: JsonValue;
+};
+export declare const CapturedTraceSchema: Schema.Struct<{
+    readonly spans: Schema.$Array<Schema.Struct<{
+        readonly traceId: Schema.String;
+        readonly spanId: Schema.String;
+        readonly parentSpanId: Schema.NullOr<Schema.String>;
+        readonly name: Schema.String;
+        readonly startTime: Schema.Number;
+        readonly endTime: Schema.NullOr<Schema.Number>;
+        readonly status: Schema.Literals<readonly ["error", "interrupted", "running", "success", "unset"]>;
+        readonly attributes: Schema.$Record<Schema.String, Schema.Codec<JsonValue, JsonValue, never, never>>;
+        readonly events: Schema.$Array<Schema.Struct<{
+            readonly name: Schema.String;
+            readonly timestamp: Schema.Number;
+            readonly attributes: Schema.$Record<Schema.String, Schema.Codec<JsonValue, JsonValue, never, never>>;
+        }>>;
+    }>>;
+    readonly logs: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly spanId: Schema.NullOr<Schema.String>;
+        readonly timestamp: Schema.Number;
+        readonly level: Schema.Literals<readonly ["Fatal", "Error", "Warn", "Info", "Debug", "Trace"]>;
+        readonly message: Schema.Codec<JsonValue, JsonValue, never, never>;
+        readonly annotations: Schema.$Record<Schema.String, Schema.Codec<JsonValue, JsonValue, never, never>>;
+    }>>;
+    readonly truncated: Schema.Boolean;
+}>;
+export declare const StoryAssertionSchema: Schema.Struct<{
+    readonly description: Schema.String;
+    readonly passed: Schema.Boolean;
+}>;
+export declare const QuestionSectionSchema: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"trace">;
+    readonly trace: Schema.Struct<{
+        readonly spans: Schema.$Array<Schema.Struct<{
+            readonly traceId: Schema.String;
+            readonly spanId: Schema.String;
+            readonly parentSpanId: Schema.NullOr<Schema.String>;
+            readonly name: Schema.String;
+            readonly startTime: Schema.Number;
+            readonly endTime: Schema.NullOr<Schema.Number>;
+            readonly status: Schema.Literals<readonly ["error", "interrupted", "running", "success", "unset"]>;
+            readonly attributes: Schema.$Record<Schema.String, Schema.Codec<JsonValue, JsonValue, never, never>>;
+            readonly events: Schema.$Array<Schema.Struct<{
+                readonly name: Schema.String;
+                readonly timestamp: Schema.Number;
+                readonly attributes: Schema.$Record<Schema.String, Schema.Codec<JsonValue, JsonValue, never, never>>;
+            }>>;
+        }>>;
+        readonly logs: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly spanId: Schema.NullOr<Schema.String>;
+            readonly timestamp: Schema.Number;
+            readonly level: Schema.Literals<readonly ["Fatal", "Error", "Warn", "Info", "Debug", "Trace"]>;
+            readonly message: Schema.Codec<JsonValue, JsonValue, never, never>;
+            readonly annotations: Schema.$Record<Schema.String, Schema.Codec<JsonValue, JsonValue, never, never>>;
+        }>>;
+        readonly truncated: Schema.Boolean;
+    }>;
+}>, Schema.Struct<{
+    readonly kind: Schema.Literal<"flow">;
+    readonly flow: Schema.Struct<{
+        readonly id: Schema.String;
+        readonly latestTimestamp: Schema.Number;
+        readonly items: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly id: Schema.String;
+            readonly participantName: Schema.String;
+            readonly name: Schema.String;
+            readonly timestamp: Schema.Number;
+            readonly attributes: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<import("@pkishorez/effect-tracer/flow").RecordedFlowAttributeValue, import("@pkishorez/effect-tracer/flow").RecordedFlowAttributeValue, never, never>>>;
+            readonly kind: Schema.Literal<"activity">;
+            readonly duration: Schema.NullOr<Schema.Number>;
+            readonly status: Schema.Literals<readonly ["error", "interrupted", "running", "success", "unset"]>;
+            readonly traceId: Schema.String;
+            readonly spanId: Schema.String;
+            readonly logs: Schema.optional<Schema.$Array<Schema.Struct<{
+                readonly timestamp: Schema.Number;
+                readonly severity: Schema.Literals<readonly ["debug", "error", "info", "warning"]>;
+                readonly message: Schema.String;
+                readonly attributes: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<import("@pkishorez/effect-tracer/flow").RecordedFlowAttributeValue, import("@pkishorez/effect-tracer/flow").RecordedFlowAttributeValue, never, never>>>;
+            }>>>;
+        }>, Schema.Struct<{
+            readonly id: Schema.String;
+            readonly participantName: Schema.String;
+            readonly name: Schema.String;
+            readonly timestamp: Schema.Number;
+            readonly attributes: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<import("@pkishorez/effect-tracer/flow").RecordedFlowAttributeValue, import("@pkishorez/effect-tracer/flow").RecordedFlowAttributeValue, never, never>>>;
+            readonly kind: Schema.Literal<"activation-end">;
+            readonly severity: Schema.Literals<readonly ["debug", "error", "info", "warning"]>;
+            readonly outcome: Schema.Literals<readonly ["completed", "failed", "interrupted"]>;
+        }>, Schema.Struct<{
+            readonly id: Schema.String;
+            readonly participantName: Schema.String;
+            readonly name: Schema.String;
+            readonly timestamp: Schema.Number;
+            readonly attributes: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<import("@pkishorez/effect-tracer/flow").RecordedFlowAttributeValue, import("@pkishorez/effect-tracer/flow").RecordedFlowAttributeValue, never, never>>>;
+            readonly kind: Schema.Literal<"activation-start">;
+            readonly severity: Schema.Literals<readonly ["debug", "error", "info", "warning"]>;
+        }>, Schema.Struct<{
+            readonly id: Schema.String;
+            readonly participantName: Schema.String;
+            readonly name: Schema.String;
+            readonly timestamp: Schema.Number;
+            readonly attributes: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<import("@pkishorez/effect-tracer/flow").RecordedFlowAttributeValue, import("@pkishorez/effect-tracer/flow").RecordedFlowAttributeValue, never, never>>>;
+            readonly kind: Schema.Literal<"local-event">;
+            readonly severity: Schema.Literals<readonly ["debug", "error", "info", "warning"]>;
+        }>, Schema.Struct<{
+            readonly id: Schema.String;
+            readonly participantName: Schema.String;
+            readonly name: Schema.String;
+            readonly timestamp: Schema.Number;
+            readonly attributes: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<import("@pkishorez/effect-tracer/flow").RecordedFlowAttributeValue, import("@pkishorez/effect-tracer/flow").RecordedFlowAttributeValue, never, never>>>;
+            readonly kind: Schema.Literal<"message">;
+            readonly severity: Schema.Literals<readonly ["debug", "error", "info", "warning"]>;
+            readonly destination: Schema.String;
+            readonly messageId: Schema.String;
+            readonly replyTo: Schema.optional<Schema.String>;
+        }>, Schema.Struct<{
+            readonly id: Schema.String;
+            readonly participantName: Schema.String;
+            readonly name: Schema.String;
+            readonly timestamp: Schema.Number;
+            readonly attributes: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<import("@pkishorez/effect-tracer/flow").RecordedFlowAttributeValue, import("@pkishorez/effect-tracer/flow").RecordedFlowAttributeValue, never, never>>>;
+            readonly kind: Schema.Literal<"state">;
+            readonly severity: Schema.Literals<readonly ["debug", "error", "info", "warning"]>;
+            readonly state: Schema.$Record<Schema.String, Schema.Codec<import("@pkishorez/effect-tracer/flow").RecordedFlowAttributeValue, import("@pkishorez/effect-tracer/flow").RecordedFlowAttributeValue, never, never>>;
+            readonly merged: Schema.$Record<Schema.String, Schema.Codec<import("@pkishorez/effect-tracer/flow").RecordedFlowAttributeValue, import("@pkishorez/effect-tracer/flow").RecordedFlowAttributeValue, never, never>>;
+        }>]>>;
+        readonly activations: Schema.$Array<Schema.Struct<{
+            readonly participantName: Schema.String;
+            readonly name: Schema.String;
+            readonly startItemId: Schema.String;
+            readonly endItemId: Schema.NullOr<Schema.String>;
+            readonly startTimestamp: Schema.Number;
+            readonly endTimestamp: Schema.NullOr<Schema.Number>;
+            readonly outcome: Schema.NullOr<Schema.Literals<readonly ["completed", "failed", "interrupted"]>>;
+        }>>;
+        readonly warnings: Schema.$Array<Schema.Struct<{
+            readonly recordType: Schema.Literals<readonly ["log", "span"]>;
+            readonly recordId: Schema.String;
+            readonly message: Schema.String;
+        }>>;
+    }>;
+}>]>;
+export declare const StoryVerdictSchema: Schema.Literals<readonly ["passed", "failed", "errored"]>;
+export declare const QuestionReportSchema: Schema.Struct<{
+    readonly slug: Schema.String;
+    readonly verdict: Schema.Literals<readonly ["passed", "failed", "errored"]>;
+    readonly result: Schema.optional<Schema.Codec<JsonValue, JsonValue, never, never>>;
+    readonly error: Schema.optional<Schema.String>;
+    readonly assertions: Schema.$Array<Schema.Struct<{
+        readonly description: Schema.String;
+        readonly passed: Schema.Boolean;
+    }>>;
+    readonly sections: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"trace">;
+        readonly trace: Schema.Struct<{
+            readonly spans: Schema.$Array<Schema.Struct<{
+                readonly traceId: Schema.String;
+                readonly spanId: Schema.String;
+                readonly parentSpanId: Schema.NullOr<Schema.String>;
+                readonly name: Schema.String;
+                readonly startTime: Schema.Number;
+                readonly endTime: Schema.NullOr<Schema.Number>;
+                readonly status: Schema.Literals<readonly ["error", "interrupted", "running", "success", "unset"]>;
+                readonly attributes: Schema.$Record<Schema.String, Schema.Codec<JsonValue, JsonValue, never, never>>;
+                readonly events: Schema.$Array<Schema.Struct<{
+                    readonly name: Schema.String;
+                    readonly timestamp: Schema.Number;
+                    readonly attributes: Schema.$Record<Schema.String, Schema.Codec<JsonValue, JsonValue, never, never>>;
+                }>>;
+            }>>;
+            readonly logs: Schema.$Array<Schema.Struct<{
+                readonly id: Schema.String;
+                readonly spanId: Schema.NullOr<Schema.String>;
+                readonly timestamp: Schema.Number;
+                readonly level: Schema.Literals<readonly ["Fatal", "Error", "Warn", "Info", "Debug", "Trace"]>;
+                readonly message: Schema.Codec<JsonValue, JsonValue, never, never>;
+                readonly annotations: Schema.$Record<Schema.String, Schema.Codec<JsonValue, JsonValue, never, never>>;
+            }>>;
+            readonly truncated: Schema.Boolean;
+        }>;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"flow">;
+        readonly flow: Schema.Struct<{
+            readonly id: Schema.String;
+            readonly latestTimestamp: Schema.Number;
+            readonly items: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                readonly id: Schema.String;
+                readonly participantName: Schema.String;
+                readonly name: Schema.String;
+                readonly timestamp: Schema.Number;
+                readonly attributes: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<import("@pkishorez/effect-tracer/flow").RecordedFlowAttributeValue, import("@pkishorez/effect-tracer/flow").RecordedFlowAttributeValue, never, never>>>;
+                readonly kind: Schema.Literal<"activity">;
+                readonly duration: Schema.NullOr<Schema.Number>;
+                readonly status: Schema.Literals<readonly ["error", "interrupted", "running", "success", "unset"]>;
+                readonly traceId: Schema.String;
+                readonly spanId: Schema.String;
+                readonly logs: Schema.optional<Schema.$Array<Schema.Struct<{
+                    readonly timestamp: Schema.Number;
+                    readonly severity: Schema.Literals<readonly ["debug", "error", "info", "warning"]>;
+                    readonly message: Schema.String;
+                    readonly attributes: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<import("@pkishorez/effect-tracer/flow").RecordedFlowAttributeValue, import("@pkishorez/effect-tracer/flow").RecordedFlowAttributeValue, never, never>>>;
+                }>>>;
+            }>, Schema.Struct<{
+                readonly id: Schema.String;
+                readonly participantName: Schema.String;
+                readonly name: Schema.String;
+                readonly timestamp: Schema.Number;
+                readonly attributes: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<import("@pkishorez/effect-tracer/flow").RecordedFlowAttributeValue, import("@pkishorez/effect-tracer/flow").RecordedFlowAttributeValue, never, never>>>;
+                readonly kind: Schema.Literal<"activation-end">;
+                readonly severity: Schema.Literals<readonly ["debug", "error", "info", "warning"]>;
+                readonly outcome: Schema.Literals<readonly ["completed", "failed", "interrupted"]>;
+            }>, Schema.Struct<{
+                readonly id: Schema.String;
+                readonly participantName: Schema.String;
+                readonly name: Schema.String;
+                readonly timestamp: Schema.Number;
+                readonly attributes: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<import("@pkishorez/effect-tracer/flow").RecordedFlowAttributeValue, import("@pkishorez/effect-tracer/flow").RecordedFlowAttributeValue, never, never>>>;
+                readonly kind: Schema.Literal<"activation-start">;
+                readonly severity: Schema.Literals<readonly ["debug", "error", "info", "warning"]>;
+            }>, Schema.Struct<{
+                readonly id: Schema.String;
+                readonly participantName: Schema.String;
+                readonly name: Schema.String;
+                readonly timestamp: Schema.Number;
+                readonly attributes: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<import("@pkishorez/effect-tracer/flow").RecordedFlowAttributeValue, import("@pkishorez/effect-tracer/flow").RecordedFlowAttributeValue, never, never>>>;
+                readonly kind: Schema.Literal<"local-event">;
+                readonly severity: Schema.Literals<readonly ["debug", "error", "info", "warning"]>;
+            }>, Schema.Struct<{
+                readonly id: Schema.String;
+                readonly participantName: Schema.String;
+                readonly name: Schema.String;
+                readonly timestamp: Schema.Number;
+                readonly attributes: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<import("@pkishorez/effect-tracer/flow").RecordedFlowAttributeValue, import("@pkishorez/effect-tracer/flow").RecordedFlowAttributeValue, never, never>>>;
+                readonly kind: Schema.Literal<"message">;
+                readonly severity: Schema.Literals<readonly ["debug", "error", "info", "warning"]>;
+                readonly destination: Schema.String;
+                readonly messageId: Schema.String;
+                readonly replyTo: Schema.optional<Schema.String>;
+            }>, Schema.Struct<{
+                readonly id: Schema.String;
+                readonly participantName: Schema.String;
+                readonly name: Schema.String;
+                readonly timestamp: Schema.Number;
+                readonly attributes: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<import("@pkishorez/effect-tracer/flow").RecordedFlowAttributeValue, import("@pkishorez/effect-tracer/flow").RecordedFlowAttributeValue, never, never>>>;
+                readonly kind: Schema.Literal<"state">;
+                readonly severity: Schema.Literals<readonly ["debug", "error", "info", "warning"]>;
+                readonly state: Schema.$Record<Schema.String, Schema.Codec<import("@pkishorez/effect-tracer/flow").RecordedFlowAttributeValue, import("@pkishorez/effect-tracer/flow").RecordedFlowAttributeValue, never, never>>;
+                readonly merged: Schema.$Record<Schema.String, Schema.Codec<import("@pkishorez/effect-tracer/flow").RecordedFlowAttributeValue, import("@pkishorez/effect-tracer/flow").RecordedFlowAttributeValue, never, never>>;
+            }>]>>;
+            readonly activations: Schema.$Array<Schema.Struct<{
+                readonly participantName: Schema.String;
+                readonly name: Schema.String;
+                readonly startItemId: Schema.String;
+                readonly endItemId: Schema.NullOr<Schema.String>;
+                readonly startTimestamp: Schema.Number;
+                readonly endTimestamp: Schema.NullOr<Schema.Number>;
+                readonly outcome: Schema.NullOr<Schema.Literals<readonly ["completed", "failed", "interrupted"]>>;
+            }>>;
+            readonly warnings: Schema.$Array<Schema.Struct<{
+                readonly recordType: Schema.Literals<readonly ["log", "span"]>;
+                readonly recordId: Schema.String;
+                readonly message: Schema.String;
+            }>>;
+        }>;
+    }>]>>;
+}>;
+export declare const StoryReportSchema: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly verdict: Schema.Literals<readonly ["passed", "failed", "errored"]>;
+    readonly questions: Schema.$Array<Schema.Struct<{
+        readonly slug: Schema.String;
+        readonly verdict: Schema.Literals<readonly ["passed", "failed", "errored"]>;
+        readonly result: Schema.optional<Schema.Codec<JsonValue, JsonValue, never, never>>;
+        readonly error: Schema.optional<Schema.String>;
+        readonly assertions: Schema.$Array<Schema.Struct<{
+            readonly description: Schema.String;
+            readonly passed: Schema.Boolean;
+        }>>;
+        readonly sections: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+            readonly kind: Schema.Literal<"trace">;
+            readonly trace: Schema.Struct<{
+                readonly spans: Schema.$Array<Schema.Struct<{
+                    readonly traceId: Schema.String;
+                    readonly spanId: Schema.String;
+                    readonly parentSpanId: Schema.NullOr<Schema.String>;
+                    readonly name: Schema.String;
+                    readonly startTime: Schema.Number;
+                    readonly endTime: Schema.NullOr<Schema.Number>;
+                    readonly status: Schema.Literals<readonly ["error", "interrupted", "running", "success", "unset"]>;
+                    readonly attributes: Schema.$Record<Schema.String, Schema.Codec<JsonValue, JsonValue, never, never>>;
+                    readonly events: Schema.$Array<Schema.Struct<{
+                        readonly name: Schema.String;
+                        readonly timestamp: Schema.Number;
+                        readonly attributes: Schema.$Record<Schema.String, Schema.Codec<JsonValue, JsonValue, never, never>>;
+                    }>>;
+                }>>;
+                readonly logs: Schema.$Array<Schema.Struct<{
+                    readonly id: Schema.String;
+                    readonly spanId: Schema.NullOr<Schema.String>;
+                    readonly timestamp: Schema.Number;
+                    readonly level: Schema.Literals<readonly ["Fatal", "Error", "Warn", "Info", "Debug", "Trace"]>;
+                    readonly message: Schema.Codec<JsonValue, JsonValue, never, never>;
+                    readonly annotations: Schema.$Record<Schema.String, Schema.Codec<JsonValue, JsonValue, never, never>>;
+                }>>;
+                readonly truncated: Schema.Boolean;
+            }>;
+        }>, Schema.Struct<{
+            readonly kind: Schema.Literal<"flow">;
+            readonly flow: Schema.Struct<{
+                readonly id: Schema.String;
+                readonly latestTimestamp: Schema.Number;
+                readonly items: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+                    readonly id: Schema.String;
+                    readonly participantName: Schema.String;
+                    readonly name: Schema.String;
+                    readonly timestamp: Schema.Number;
+                    readonly attributes: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<import("@pkishorez/effect-tracer/flow").RecordedFlowAttributeValue, import("@pkishorez/effect-tracer/flow").RecordedFlowAttributeValue, never, never>>>;
+                    readonly kind: Schema.Literal<"activity">;
+                    readonly duration: Schema.NullOr<Schema.Number>;
+                    readonly status: Schema.Literals<readonly ["error", "interrupted", "running", "success", "unset"]>;
+                    readonly traceId: Schema.String;
+                    readonly spanId: Schema.String;
+                    readonly logs: Schema.optional<Schema.$Array<Schema.Struct<{
+                        readonly timestamp: Schema.Number;
+                        readonly severity: Schema.Literals<readonly ["debug", "error", "info", "warning"]>;
+                        readonly message: Schema.String;
+                        readonly attributes: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<import("@pkishorez/effect-tracer/flow").RecordedFlowAttributeValue, import("@pkishorez/effect-tracer/flow").RecordedFlowAttributeValue, never, never>>>;
+                    }>>>;
+                }>, Schema.Struct<{
+                    readonly id: Schema.String;
+                    readonly participantName: Schema.String;
+                    readonly name: Schema.String;
+                    readonly timestamp: Schema.Number;
+                    readonly attributes: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<import("@pkishorez/effect-tracer/flow").RecordedFlowAttributeValue, import("@pkishorez/effect-tracer/flow").RecordedFlowAttributeValue, never, never>>>;
+                    readonly kind: Schema.Literal<"activation-end">;
+                    readonly severity: Schema.Literals<readonly ["debug", "error", "info", "warning"]>;
+                    readonly outcome: Schema.Literals<readonly ["completed", "failed", "interrupted"]>;
+                }>, Schema.Struct<{
+                    readonly id: Schema.String;
+                    readonly participantName: Schema.String;
+                    readonly name: Schema.String;
+                    readonly timestamp: Schema.Number;
+                    readonly attributes: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<import("@pkishorez/effect-tracer/flow").RecordedFlowAttributeValue, import("@pkishorez/effect-tracer/flow").RecordedFlowAttributeValue, never, never>>>;
+                    readonly kind: Schema.Literal<"activation-start">;
+                    readonly severity: Schema.Literals<readonly ["debug", "error", "info", "warning"]>;
+                }>, Schema.Struct<{
+                    readonly id: Schema.String;
+                    readonly participantName: Schema.String;
+                    readonly name: Schema.String;
+                    readonly timestamp: Schema.Number;
+                    readonly attributes: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<import("@pkishorez/effect-tracer/flow").RecordedFlowAttributeValue, import("@pkishorez/effect-tracer/flow").RecordedFlowAttributeValue, never, never>>>;
+                    readonly kind: Schema.Literal<"local-event">;
+                    readonly severity: Schema.Literals<readonly ["debug", "error", "info", "warning"]>;
+                }>, Schema.Struct<{
+                    readonly id: Schema.String;
+                    readonly participantName: Schema.String;
+                    readonly name: Schema.String;
+                    readonly timestamp: Schema.Number;
+                    readonly attributes: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<import("@pkishorez/effect-tracer/flow").RecordedFlowAttributeValue, import("@pkishorez/effect-tracer/flow").RecordedFlowAttributeValue, never, never>>>;
+                    readonly kind: Schema.Literal<"message">;
+                    readonly severity: Schema.Literals<readonly ["debug", "error", "info", "warning"]>;
+                    readonly destination: Schema.String;
+                    readonly messageId: Schema.String;
+                    readonly replyTo: Schema.optional<Schema.String>;
+                }>, Schema.Struct<{
+                    readonly id: Schema.String;
+                    readonly participantName: Schema.String;
+                    readonly name: Schema.String;
+                    readonly timestamp: Schema.Number;
+                    readonly attributes: Schema.optional<Schema.$Record<Schema.String, Schema.Codec<import("@pkishorez/effect-tracer/flow").RecordedFlowAttributeValue, import("@pkishorez/effect-tracer/flow").RecordedFlowAttributeValue, never, never>>>;
+                    readonly kind: Schema.Literal<"state">;
+                    readonly severity: Schema.Literals<readonly ["debug", "error", "info", "warning"]>;
+                    readonly state: Schema.$Record<Schema.String, Schema.Codec<import("@pkishorez/effect-tracer/flow").RecordedFlowAttributeValue, import("@pkishorez/effect-tracer/flow").RecordedFlowAttributeValue, never, never>>;
+                    readonly merged: Schema.$Record<Schema.String, Schema.Codec<import("@pkishorez/effect-tracer/flow").RecordedFlowAttributeValue, import("@pkishorez/effect-tracer/flow").RecordedFlowAttributeValue, never, never>>;
+                }>]>>;
+                readonly activations: Schema.$Array<Schema.Struct<{
+                    readonly participantName: Schema.String;
+                    readonly name: Schema.String;
+                    readonly startItemId: Schema.String;
+                    readonly endItemId: Schema.NullOr<Schema.String>;
+                    readonly startTimestamp: Schema.Number;
+                    readonly endTimestamp: Schema.NullOr<Schema.Number>;
+                    readonly outcome: Schema.NullOr<Schema.Literals<readonly ["completed", "failed", "interrupted"]>>;
+                }>>;
+                readonly warnings: Schema.$Array<Schema.Struct<{
+                    readonly recordType: Schema.Literals<readonly ["log", "span"]>;
+                    readonly recordId: Schema.String;
+                    readonly message: Schema.String;
+                }>>;
+            }>;
+        }>]>>;
+    }>>;
+}>;
+export type CapturedTrace = typeof CapturedTraceSchema.Type;
+export type RecordedFlow = typeof RecordedFlowSchema.Type;
+export type StoryAssertion = typeof StoryAssertionSchema.Type;
+export type QuestionSection = typeof QuestionSectionSchema.Type;
+export type QuestionReport = typeof QuestionReportSchema.Type;
+export type StoryVerdict = typeof StoryVerdictSchema.Type;
+export type StoryReport = typeof StoryReportSchema.Type;
+//# sourceMappingURL=story-report-schema.d.ts.map

package/dist/story/schema/story-report-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"story-report-schema.d.ts","sourceRoot":"","sources":["../../../src/story/schema/story-report-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AAEnE,OAAO,EAAE,kBAAkB,EAAE,CAAC;AAc9B,MAAM,MAAM,SAAS,GACjB,MAAM,GACN,MAAM,GACN,OAAO,GACP,IAAI,GACJ,SAAS,SAAS,EAAE,GACpB;IAAE,QAAQ,EAAE,GAAG,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,CAAC;AAqC1C,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;EAQ9B,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;EAO/B,CAAC;AAEH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAahC,CAAC;AAEH,eAAO,MAAM,kBAAkB,2DAI7B,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAW/B,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAQ5B,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,OAAO,mBAAmB,CAAC,IAAI,CAAC;AAC5D,MAAM,MAAM,YAAY,GAAG,OAAO,kBAAkB,CAAC,IAAI,CAAC;AAC1D,MAAM,MAAM,cAAc,GAAG,OAAO,oBAAoB,CAAC,IAAI,CAAC;AAC9D,MAAM,MAAM,eAAe,GAAG,OAAO,qBAAqB,CAAC,IAAI,CAAC;AAChE,MAAM,MAAM,cAAc,GAAG,OAAO,oBAAoB,CAAC,IAAI,CAAC;AAC9D,MAAM,MAAM,YAAY,GAAG,OAAO,kBAAkB,CAAC,IAAI,CAAC;AAC1D,MAAM,MAAM,WAAW,GAAG,OAAO,iBAAiB,CAAC,IAAI,CAAC"}

package/dist/story/schema/story-report-schema.js

@@ -0,0 +1,94 @@
+import { Schema } from 'effect';
+import { RecordedFlowSchema } from '@pkishorez/effect-tracer/flow';
+export { RecordedFlowSchema };
+const JsonValueSchema = Schema.Union([
+    Schema.String,
+    Schema.Number,
+    Schema.Boolean,
+    Schema.Null,
+    Schema.Array(Schema.suspend(() => JsonValueSchema)),
+    Schema.Record(Schema.String, Schema.suspend(() => JsonValueSchema)),
+]);
+const SpanStatusSchema = Schema.Literals([
+    'error',
+    'interrupted',
+    'running',
+    'success',
+    'unset',
+]);
+const CapturedEventSchema = Schema.Struct({
+    name: Schema.String,
+    timestamp: Schema.Number,
+    attributes: Schema.Record(Schema.String, JsonValueSchema),
+});
+const CapturedSpanSchema = Schema.Struct({
+    traceId: Schema.String,
+    spanId: Schema.String,
+    parentSpanId: Schema.NullOr(Schema.String),
+    name: Schema.String,
+    startTime: Schema.Number,
+    endTime: Schema.NullOr(Schema.Number),
+    status: SpanStatusSchema,
+    attributes: Schema.Record(Schema.String, JsonValueSchema),
+    events: Schema.Array(CapturedEventSchema),
+});
+const CapturedLogSchema = Schema.Struct({
+    id: Schema.String,
+    spanId: Schema.NullOr(Schema.String),
+    timestamp: Schema.Number,
+    level: Schema.Literals(['Fatal', 'Error', 'Warn', 'Info', 'Debug', 'Trace']),
+    message: JsonValueSchema,
+    annotations: Schema.Record(Schema.String, JsonValueSchema),
+});
+export const CapturedTraceSchema = Schema.Struct({
+    spans: Schema.Array(CapturedSpanSchema),
+    logs: Schema.Array(CapturedLogSchema),
+    truncated: Schema.Boolean,
+}).annotate({
+    title: 'Captured Trace',
+    description: "A Story artifact: every span and log recorded while a Story's traced region ran.",
+});
+export const StoryAssertionSchema = Schema.Struct({
+    description: Schema.String,
+    passed: Schema.Boolean,
+}).annotate({
+    title: 'Story Assertion',
+    description: "One recorded assertion outcome pinning a Question's answer to its captured proof.",
+});
+export const QuestionSectionSchema = Schema.Union([
+    Schema.Struct({
+        kind: Schema.Literal('trace'),
+        trace: CapturedTraceSchema,
+    }),
+    Schema.Struct({
+        kind: Schema.Literal('flow'),
+        flow: RecordedFlowSchema,
+    }),
+]).annotate({
+    title: 'Question Section',
+    description: "One captured artifact of a Question's proof run: a trace or a flow.",
+});
+export const StoryVerdictSchema = Schema.Literals([
+    'passed',
+    'failed',
+    'errored',
+]);
+export const QuestionReportSchema = Schema.Struct({
+    slug: Schema.String,
+    verdict: StoryVerdictSchema,
+    result: Schema.optional(JsonValueSchema),
+    error: Schema.optional(Schema.String),
+    assertions: Schema.Array(StoryAssertionSchema),
+    sections: Schema.Array(QuestionSectionSchema),
+}).annotate({
+    title: 'Question Report',
+    description: "The structured record of one Question's proof run: the captured result (or error), the assertions pinning the answer, and any captured sections.",
+});
+export const StoryReportSchema = Schema.Struct({
+    id: Schema.String,
+    verdict: StoryVerdictSchema,
+    questions: Schema.Array(QuestionReportSchema),
+}).annotate({
+    title: 'Story Report',
+    description: "The structured record of one Story run, attached to the Story tree by the Story's id: one Question report per authored Question, in order.",
+});

package/dist/story/schema/story-tree-schema.d.ts

@@ -0,0 +1,42 @@
+import { Schema } from 'effect';
+export declare const StorySourceSchema: Schema.Struct<{
+    readonly path: Schema.String;
+    readonly content: Schema.String;
+}>;
+export declare const QuestionLeafSchema: Schema.Struct<{
+    readonly slug: Schema.String;
+    readonly question: Schema.String;
+    readonly answer: Schema.String;
+    readonly snippet: Schema.String;
+}>;
+export declare const StoryLeafSchema: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly title: Schema.String;
+    readonly setup: Schema.NullOr<Schema.String>;
+    readonly questions: Schema.$Array<Schema.Struct<{
+        readonly slug: Schema.String;
+        readonly question: Schema.String;
+        readonly answer: Schema.String;
+        readonly snippet: Schema.String;
+    }>>;
+    readonly source: Schema.Struct<{
+        readonly path: Schema.String;
+        readonly content: Schema.String;
+    }>;
+    readonly support: Schema.NullOr<Schema.Struct<{
+        readonly path: Schema.String;
+        readonly content: Schema.String;
+    }>>;
+}>;
+export interface StoryTreeGroup {
+    readonly title: string;
+    readonly groups: readonly StoryTreeGroup[];
+    readonly stories: readonly (typeof StoryLeafSchema.Type)[];
+}
+export declare const StoryTreeGroupSchema: Schema.Codec<StoryTreeGroup>;
+export declare const StoryTreeSchema: Schema.Codec<StoryTreeGroup, StoryTreeGroup, never, never>;
+export type QuestionLeaf = typeof QuestionLeafSchema.Type;
+export type StoryLeaf = typeof StoryLeafSchema.Type;
+export type StorySource = typeof StorySourceSchema.Type;
+export type StoryTree = StoryTreeGroup;
+//# sourceMappingURL=story-tree-schema.d.ts.map

package/dist/story/schema/story-tree-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"story-tree-schema.d.ts","sourceRoot":"","sources":["../../../src/story/schema/story-tree-schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,eAAO,MAAM,iBAAiB;;;EAO5B,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;EAS7B,CAAC;AAEH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;EAW1B,CAAC;AAEH,MAAM,WAAW,cAAc;IAC7B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,MAAM,EAAE,SAAS,cAAc,EAAE,CAAC;IAC3C,QAAQ,CAAC,OAAO,EAAE,SAAS,CAAC,OAAO,eAAe,CAAC,IAAI,CAAC,EAAE,CAAC;CAC5D;AAED,eAAO,MAAM,oBAAoB,EAAE,MAAM,CAAC,KAAK,CAAC,cAAc,CAUjB,CAAC;AAE9C,eAAO,MAAM,eAAe,4DAI1B,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,OAAO,kBAAkB,CAAC,IAAI,CAAC;AAC1D,MAAM,MAAM,SAAS,GAAG,OAAO,eAAe,CAAC,IAAI,CAAC;AACpD,MAAM,MAAM,WAAW,GAAG,OAAO,iBAAiB,CAAC,IAAI,CAAC;AACxD,MAAM,MAAM,SAAS,GAAG,cAAc,CAAC"}

package/dist/story/schema/story-tree-schema.js

@@ -0,0 +1,40 @@
+import { Schema } from 'effect';
+export const StorySourceSchema = Schema.Struct({
+    path: Schema.String,
+    content: Schema.String,
+}).annotate({
+    title: 'Story Source',
+    description: 'The full text of a project file backing a Story: the file the Story was authored in, or the support file its proofs import.',
+});
+export const QuestionLeafSchema = Schema.Struct({
+    slug: Schema.String,
+    question: Schema.String,
+    answer: Schema.String,
+    snippet: Schema.String,
+}).annotate({
+    title: 'Question Leaf',
+    description: 'One Question of a Story: the question, its one-sentence answer, and the literal source of the proof effect extracted from the Story file.',
+});
+export const StoryLeafSchema = Schema.Struct({
+    id: Schema.String,
+    title: Schema.String,
+    setup: Schema.NullOr(Schema.String),
+    questions: Schema.Array(QuestionLeafSchema),
+    source: StorySourceSchema,
+    support: Schema.NullOr(StorySourceSchema),
+}).annotate({
+    title: 'Story Leaf',
+    description: 'One Story in the Story tree: its derived id, the shared setup snippet, its Questions in authored order, and the support file its proofs import. Never carries results.',
+});
+export const StoryTreeGroupSchema = Schema.Struct({
+    title: Schema.String,
+    groups: Schema.Array(Schema.suspend(() => StoryTreeGroupSchema)),
+    stories: Schema.Array(StoryLeafSchema),
+}).annotate({
+    title: 'Story Group',
+    description: 'One node of the Story tree: a title over any mix of subgroups and Story leaves.',
+});
+export const StoryTreeSchema = StoryTreeGroupSchema.annotate({
+    title: 'Story Tree',
+    description: "A Project's whole Story hierarchy, rooted at the barrel's default export. Metadata only; no Story executes to produce it.",
+});

package/dist/story/story.d.ts

@@ -0,0 +1,38 @@
+import { Context, Effect } from 'effect';
+import type { QuestionSection } from './schema/index.js';
+declare const StoryContext_base: Context.ServiceClass<StoryContext, "StoryContext", {
+    readonly beginSection: (section: QuestionSection) => Effect.Effect<void>;
+    readonly assert: (description: string, passed: boolean) => Effect.Effect<void>;
+}>;
+export declare class StoryContext extends StoryContext_base {
+}
+export interface StoryQuestion {
+    readonly question: string;
+    readonly answer: string;
+    readonly proof: Effect.Effect<unknown, unknown, StoryContext>;
+}
+export interface Story {
+    readonly title: string;
+    readonly sourceUrl: string;
+    readonly questions: readonly StoryQuestion[];
+}
+export interface StoryGroup {
+    readonly title: string;
+    readonly children: readonly StoryNode[];
+}
+export type StoryNode = Story | StoryGroup;
+export declare const Story: {
+    make(story: Story): Story;
+    question(question: string, options: {
+        readonly answer: string;
+        readonly proof: Effect.Effect<unknown, unknown, StoryContext>;
+    }): StoryQuestion;
+    group(title: string, children: readonly StoryNode[]): StoryGroup;
+    trace<A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R | StoryContext>;
+    flow<A, E, R>(effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R | StoryContext>;
+    assert(description: string, passed: boolean): Effect.Effect<void, never, StoryContext>;
+};
+export declare function isStory(value: unknown): value is Story;
+export declare function isStoryGroup(value: unknown): value is StoryGroup;
+export {};
+//# sourceMappingURL=story.d.ts.map

package/dist/story/story.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"story.d.ts","sourceRoot":"","sources":["../../src/story/story.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAGzC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;;2BAK9B,CAAC,OAAO,EAAE,eAAe,KAAK,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC;qBACvD,CACf,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,OAAO,KACZ,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC;;AAP5B,qBAAa,YAAa,SAAQ,iBASf;CAAG;AAEtB,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,YAAY,CAAC,CAAC;CAC/D;AAED,MAAM,WAAW,KAAK;IACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,EAAE,SAAS,aAAa,EAAE,CAAC;CAC9C;AAED,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,QAAQ,EAAE,SAAS,SAAS,EAAE,CAAC;CACzC;AAED,MAAM,MAAM,SAAS,GAAG,KAAK,GAAG,UAAU,CAAC;AAE3C,eAAO,MAAM,KAAK;IAChB,IAAI,QAAQ,KAAK,GAAG,KAAK;IAIzB,QAAQ,WACI,MAAM,WACP;QACP,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;QACxB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,YAAY,CAAC,CAAC;KAC/D,GACA,aAAa;IAIhB,KAAK,QAAQ,MAAM,YAAY,SAAS,SAAS,EAAE,GAAG,UAAU;IAIhE,KAAK,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,UACH,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,GAC7B,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,YAAY,CAAC;IAcxC,IAAI,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,UACF,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,GAC7B,MAAM,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,YAAY,CAAC;IAgBxC,MAAM,cACS,MAAM,UACX,OAAO,GACd,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,KAAK,EAAE,YAAY,CAAC;CAK5C,CAAC;AAEF,wBAAgB,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,KAAK,CActD;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,UAAU,CAOhE"}