laymos 0.0.1 → 0.0.2

package/dist/report/tests.d.ts

@@ -0,0 +1,411 @@
+import { Schema } from 'effect';
+import type { CapturedEvent, CapturedLog, CapturedSpan } from '@pkishorez/effect-tracer/recorder';
+export type TestStatus = 'passed' | 'failed' | 'skipped' | 'pending';
+export type TestValue = string | number | boolean | null | readonly TestValue[] | {
+    readonly [key: string]: TestValue;
+};
+export interface TestErrorReport {
+    readonly name: string;
+    readonly message: string;
+    readonly stack?: string | undefined;
+    readonly expected?: string | undefined;
+    readonly actual?: string | undefined;
+    readonly diff?: string | undefined;
+}
+export interface TestSourceLocation {
+    readonly line: number;
+    readonly column: number;
+}
+export interface TestAssertionEvidence {
+    readonly name: string;
+    readonly matcher: string;
+    readonly status: 'passed' | 'failed';
+    readonly actual?: TestValue | undefined;
+    readonly expected?: TestValue | undefined;
+    readonly error?: TestErrorReport | undefined;
+}
+export type TestTraceEvent = CapturedEvent;
+export type TestTraceLog = CapturedLog;
+export type TestTraceSpan = CapturedSpan;
+export interface LaymosTestEvidence {
+    readonly description: string;
+    readonly documentation?: string | undefined;
+    readonly assertions: readonly TestAssertionEvidence[];
+    readonly trace?: {
+        readonly spans: readonly TestTraceSpan[];
+        readonly logs: readonly TestTraceLog[];
+    } | undefined;
+}
+export interface TestCaseReport {
+    readonly id: string;
+    readonly name: string;
+    readonly fullName: string;
+    readonly status: TestStatus;
+    readonly duration: number;
+    readonly errors: readonly TestErrorReport[];
+    readonly location?: TestSourceLocation | undefined;
+    readonly authoredBy?: 'laymos' | undefined;
+    readonly evidence?: LaymosTestEvidence | undefined;
+}
+export interface TestSuiteReport {
+    readonly id: string;
+    readonly name: string;
+    readonly description?: string | undefined;
+    readonly documentation?: string | undefined;
+    readonly status: TestStatus;
+    readonly suites: readonly TestSuiteReport[];
+    readonly cases: readonly TestCaseReport[];
+    readonly errors: readonly TestErrorReport[];
+}
+export interface TestModuleReport {
+    readonly id: string;
+    readonly name: string;
+    readonly path: string;
+    readonly projectName: string;
+    readonly status: TestStatus;
+    readonly duration: number;
+    readonly suites: readonly TestSuiteReport[];
+    readonly cases: readonly TestCaseReport[];
+    readonly errors: readonly TestErrorReport[];
+}
+export interface TestsReport {
+    readonly status: 'passed' | 'failed';
+    readonly duration: number;
+    readonly modules: readonly TestModuleReport[];
+    readonly unhandledErrors: readonly TestErrorReport[];
+}
+export declare const TestValueSchema: Schema.Codec<TestValue>;
+export declare const TestErrorReportSchema: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly message: Schema.String;
+    readonly stack: Schema.optional<Schema.String>;
+    readonly expected: Schema.optional<Schema.String>;
+    readonly actual: Schema.optional<Schema.String>;
+    readonly diff: Schema.optional<Schema.String>;
+}>;
+export declare const TestSourceLocationSchema: Schema.Struct<{
+    readonly line: Schema.Number;
+    readonly column: Schema.Number;
+}>;
+export declare const TestAssertionEvidenceSchema: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly matcher: Schema.String;
+    readonly status: Schema.Literals<readonly ["passed", "failed"]>;
+    readonly actual: Schema.optional<Schema.Codec<TestValue, TestValue, never, never>>;
+    readonly expected: Schema.optional<Schema.Codec<TestValue, TestValue, never, never>>;
+    readonly error: Schema.optional<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly message: Schema.String;
+        readonly stack: Schema.optional<Schema.String>;
+        readonly expected: Schema.optional<Schema.String>;
+        readonly actual: Schema.optional<Schema.String>;
+        readonly diff: Schema.optional<Schema.String>;
+    }>>;
+}>;
+export declare const TestTraceEventSchema: Schema.Struct<{
+    readonly name: Schema.String;
+    readonly timestamp: Schema.Number;
+    readonly attributes: Schema.$Record<Schema.String, Schema.Codec<TestValue, TestValue, never, never>>;
+}>;
+export declare const TestTraceLogSchema: Schema.Struct<{
+    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<TestValue, TestValue, never, never>;
+    readonly annotations: Schema.$Record<Schema.String, Schema.Codec<TestValue, TestValue, never, never>>;
+}>;
+export declare const TestTraceSpanSchema: 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 ["success", "error", "running", "unset"]>;
+    readonly attributes: Schema.$Record<Schema.String, Schema.Codec<TestValue, TestValue, never, never>>;
+    readonly events: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly timestamp: Schema.Number;
+        readonly attributes: Schema.$Record<Schema.String, Schema.Codec<TestValue, TestValue, never, never>>;
+    }>>;
+}>;
+export declare const LaymosTestEvidenceSchema: Schema.Struct<{
+    readonly description: Schema.String;
+    readonly documentation: Schema.optional<Schema.String>;
+    readonly assertions: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly matcher: Schema.String;
+        readonly status: Schema.Literals<readonly ["passed", "failed"]>;
+        readonly actual: Schema.optional<Schema.Codec<TestValue, TestValue, never, never>>;
+        readonly expected: Schema.optional<Schema.Codec<TestValue, TestValue, never, never>>;
+        readonly error: Schema.optional<Schema.Struct<{
+            readonly name: Schema.String;
+            readonly message: Schema.String;
+            readonly stack: Schema.optional<Schema.String>;
+            readonly expected: Schema.optional<Schema.String>;
+            readonly actual: Schema.optional<Schema.String>;
+            readonly diff: Schema.optional<Schema.String>;
+        }>>;
+    }>>;
+    readonly trace: Schema.optional<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 ["success", "error", "running", "unset"]>;
+            readonly attributes: Schema.$Record<Schema.String, Schema.Codec<TestValue, TestValue, never, never>>;
+            readonly events: Schema.$Array<Schema.Struct<{
+                readonly name: Schema.String;
+                readonly timestamp: Schema.Number;
+                readonly attributes: Schema.$Record<Schema.String, Schema.Codec<TestValue, TestValue, never, never>>;
+            }>>;
+        }>>;
+        readonly logs: Schema.$Array<Schema.Struct<{
+            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<TestValue, TestValue, never, never>;
+            readonly annotations: Schema.$Record<Schema.String, Schema.Codec<TestValue, TestValue, never, never>>;
+        }>>;
+    }>>;
+}>;
+export declare const TestCaseReportSchema: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly name: Schema.String;
+    readonly fullName: Schema.String;
+    readonly status: Schema.Literals<readonly ["passed", "failed", "skipped", "pending"]>;
+    readonly duration: Schema.Number;
+    readonly errors: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly message: Schema.String;
+        readonly stack: Schema.optional<Schema.String>;
+        readonly expected: Schema.optional<Schema.String>;
+        readonly actual: Schema.optional<Schema.String>;
+        readonly diff: Schema.optional<Schema.String>;
+    }>>;
+    readonly location: Schema.optional<Schema.Struct<{
+        readonly line: Schema.Number;
+        readonly column: Schema.Number;
+    }>>;
+    readonly authoredBy: Schema.optional<Schema.Literal<"laymos">>;
+    readonly evidence: Schema.optional<Schema.Struct<{
+        readonly description: Schema.String;
+        readonly documentation: Schema.optional<Schema.String>;
+        readonly assertions: Schema.$Array<Schema.Struct<{
+            readonly name: Schema.String;
+            readonly matcher: Schema.String;
+            readonly status: Schema.Literals<readonly ["passed", "failed"]>;
+            readonly actual: Schema.optional<Schema.Codec<TestValue, TestValue, never, never>>;
+            readonly expected: Schema.optional<Schema.Codec<TestValue, TestValue, never, never>>;
+            readonly error: Schema.optional<Schema.Struct<{
+                readonly name: Schema.String;
+                readonly message: Schema.String;
+                readonly stack: Schema.optional<Schema.String>;
+                readonly expected: Schema.optional<Schema.String>;
+                readonly actual: Schema.optional<Schema.String>;
+                readonly diff: Schema.optional<Schema.String>;
+            }>>;
+        }>>;
+        readonly trace: Schema.optional<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 ["success", "error", "running", "unset"]>;
+                readonly attributes: Schema.$Record<Schema.String, Schema.Codec<TestValue, TestValue, never, never>>;
+                readonly events: Schema.$Array<Schema.Struct<{
+                    readonly name: Schema.String;
+                    readonly timestamp: Schema.Number;
+                    readonly attributes: Schema.$Record<Schema.String, Schema.Codec<TestValue, TestValue, never, never>>;
+                }>>;
+            }>>;
+            readonly logs: Schema.$Array<Schema.Struct<{
+                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<TestValue, TestValue, never, never>;
+                readonly annotations: Schema.$Record<Schema.String, Schema.Codec<TestValue, TestValue, never, never>>;
+            }>>;
+        }>>;
+    }>>;
+}>;
+export declare const TestSuiteReportSchema: Schema.Codec<TestSuiteReport>;
+export declare const TestModuleReportSchema: Schema.Struct<{
+    readonly id: Schema.String;
+    readonly name: Schema.String;
+    readonly path: Schema.String;
+    readonly projectName: Schema.String;
+    readonly status: Schema.Literals<readonly ["passed", "failed", "skipped", "pending"]>;
+    readonly duration: Schema.Number;
+    readonly suites: Schema.$Array<Schema.Codec<TestSuiteReport, TestSuiteReport, never, never>>;
+    readonly cases: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly name: Schema.String;
+        readonly fullName: Schema.String;
+        readonly status: Schema.Literals<readonly ["passed", "failed", "skipped", "pending"]>;
+        readonly duration: Schema.Number;
+        readonly errors: Schema.$Array<Schema.Struct<{
+            readonly name: Schema.String;
+            readonly message: Schema.String;
+            readonly stack: Schema.optional<Schema.String>;
+            readonly expected: Schema.optional<Schema.String>;
+            readonly actual: Schema.optional<Schema.String>;
+            readonly diff: Schema.optional<Schema.String>;
+        }>>;
+        readonly location: Schema.optional<Schema.Struct<{
+            readonly line: Schema.Number;
+            readonly column: Schema.Number;
+        }>>;
+        readonly authoredBy: Schema.optional<Schema.Literal<"laymos">>;
+        readonly evidence: Schema.optional<Schema.Struct<{
+            readonly description: Schema.String;
+            readonly documentation: Schema.optional<Schema.String>;
+            readonly assertions: Schema.$Array<Schema.Struct<{
+                readonly name: Schema.String;
+                readonly matcher: Schema.String;
+                readonly status: Schema.Literals<readonly ["passed", "failed"]>;
+                readonly actual: Schema.optional<Schema.Codec<TestValue, TestValue, never, never>>;
+                readonly expected: Schema.optional<Schema.Codec<TestValue, TestValue, never, never>>;
+                readonly error: Schema.optional<Schema.Struct<{
+                    readonly name: Schema.String;
+                    readonly message: Schema.String;
+                    readonly stack: Schema.optional<Schema.String>;
+                    readonly expected: Schema.optional<Schema.String>;
+                    readonly actual: Schema.optional<Schema.String>;
+                    readonly diff: Schema.optional<Schema.String>;
+                }>>;
+            }>>;
+            readonly trace: Schema.optional<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 ["success", "error", "running", "unset"]>;
+                    readonly attributes: Schema.$Record<Schema.String, Schema.Codec<TestValue, TestValue, never, never>>;
+                    readonly events: Schema.$Array<Schema.Struct<{
+                        readonly name: Schema.String;
+                        readonly timestamp: Schema.Number;
+                        readonly attributes: Schema.$Record<Schema.String, Schema.Codec<TestValue, TestValue, never, never>>;
+                    }>>;
+                }>>;
+                readonly logs: Schema.$Array<Schema.Struct<{
+                    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<TestValue, TestValue, never, never>;
+                    readonly annotations: Schema.$Record<Schema.String, Schema.Codec<TestValue, TestValue, never, never>>;
+                }>>;
+            }>>;
+        }>>;
+    }>>;
+    readonly errors: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly message: Schema.String;
+        readonly stack: Schema.optional<Schema.String>;
+        readonly expected: Schema.optional<Schema.String>;
+        readonly actual: Schema.optional<Schema.String>;
+        readonly diff: Schema.optional<Schema.String>;
+    }>>;
+}>;
+export declare const TestsReportSchema: Schema.Struct<{
+    readonly status: Schema.Literals<readonly ["passed", "failed"]>;
+    readonly duration: Schema.Number;
+    readonly modules: Schema.$Array<Schema.Struct<{
+        readonly id: Schema.String;
+        readonly name: Schema.String;
+        readonly path: Schema.String;
+        readonly projectName: Schema.String;
+        readonly status: Schema.Literals<readonly ["passed", "failed", "skipped", "pending"]>;
+        readonly duration: Schema.Number;
+        readonly suites: Schema.$Array<Schema.Codec<TestSuiteReport, TestSuiteReport, never, never>>;
+        readonly cases: Schema.$Array<Schema.Struct<{
+            readonly id: Schema.String;
+            readonly name: Schema.String;
+            readonly fullName: Schema.String;
+            readonly status: Schema.Literals<readonly ["passed", "failed", "skipped", "pending"]>;
+            readonly duration: Schema.Number;
+            readonly errors: Schema.$Array<Schema.Struct<{
+                readonly name: Schema.String;
+                readonly message: Schema.String;
+                readonly stack: Schema.optional<Schema.String>;
+                readonly expected: Schema.optional<Schema.String>;
+                readonly actual: Schema.optional<Schema.String>;
+                readonly diff: Schema.optional<Schema.String>;
+            }>>;
+            readonly location: Schema.optional<Schema.Struct<{
+                readonly line: Schema.Number;
+                readonly column: Schema.Number;
+            }>>;
+            readonly authoredBy: Schema.optional<Schema.Literal<"laymos">>;
+            readonly evidence: Schema.optional<Schema.Struct<{
+                readonly description: Schema.String;
+                readonly documentation: Schema.optional<Schema.String>;
+                readonly assertions: Schema.$Array<Schema.Struct<{
+                    readonly name: Schema.String;
+                    readonly matcher: Schema.String;
+                    readonly status: Schema.Literals<readonly ["passed", "failed"]>;
+                    readonly actual: Schema.optional<Schema.Codec<TestValue, TestValue, never, never>>;
+                    readonly expected: Schema.optional<Schema.Codec<TestValue, TestValue, never, never>>;
+                    readonly error: Schema.optional<Schema.Struct<{
+                        readonly name: Schema.String;
+                        readonly message: Schema.String;
+                        readonly stack: Schema.optional<Schema.String>;
+                        readonly expected: Schema.optional<Schema.String>;
+                        readonly actual: Schema.optional<Schema.String>;
+                        readonly diff: Schema.optional<Schema.String>;
+                    }>>;
+                }>>;
+                readonly trace: Schema.optional<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 ["success", "error", "running", "unset"]>;
+                        readonly attributes: Schema.$Record<Schema.String, Schema.Codec<TestValue, TestValue, never, never>>;
+                        readonly events: Schema.$Array<Schema.Struct<{
+                            readonly name: Schema.String;
+                            readonly timestamp: Schema.Number;
+                            readonly attributes: Schema.$Record<Schema.String, Schema.Codec<TestValue, TestValue, never, never>>;
+                        }>>;
+                    }>>;
+                    readonly logs: Schema.$Array<Schema.Struct<{
+                        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<TestValue, TestValue, never, never>;
+                        readonly annotations: Schema.$Record<Schema.String, Schema.Codec<TestValue, TestValue, never, never>>;
+                    }>>;
+                }>>;
+            }>>;
+        }>>;
+        readonly errors: Schema.$Array<Schema.Struct<{
+            readonly name: Schema.String;
+            readonly message: Schema.String;
+            readonly stack: Schema.optional<Schema.String>;
+            readonly expected: Schema.optional<Schema.String>;
+            readonly actual: Schema.optional<Schema.String>;
+            readonly diff: Schema.optional<Schema.String>;
+        }>>;
+    }>>;
+    readonly unhandledErrors: Schema.$Array<Schema.Struct<{
+        readonly name: Schema.String;
+        readonly message: Schema.String;
+        readonly stack: Schema.optional<Schema.String>;
+        readonly expected: Schema.optional<Schema.String>;
+        readonly actual: Schema.optional<Schema.String>;
+        readonly diff: Schema.optional<Schema.String>;
+    }>>;
+}>;
+//# sourceMappingURL=tests.d.ts.map

package/dist/report/tests.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tests.d.ts","sourceRoot":"","sources":["../../src/report/tests.ts"],"names":[],"mappings":"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"}

package/dist/report/tests.js

@@ -0,0 +1,102 @@
+import { Schema } from 'effect';
+export const TestValueSchema = Schema.suspend(() => Schema.Union([
+    Schema.String,
+    Schema.Number,
+    Schema.Boolean,
+    Schema.Null,
+    Schema.Array(TestValueSchema),
+    Schema.Record(Schema.String, TestValueSchema),
+]));
+export const TestErrorReportSchema = Schema.Struct({
+    name: Schema.String,
+    message: Schema.String,
+    stack: Schema.optional(Schema.String),
+    expected: Schema.optional(Schema.String),
+    actual: Schema.optional(Schema.String),
+    diff: Schema.optional(Schema.String),
+});
+export const TestSourceLocationSchema = Schema.Struct({
+    line: Schema.Number,
+    column: Schema.Number,
+});
+export const TestAssertionEvidenceSchema = Schema.Struct({
+    name: Schema.String,
+    matcher: Schema.String,
+    status: Schema.Literals(['passed', 'failed']),
+    actual: Schema.optional(TestValueSchema),
+    expected: Schema.optional(TestValueSchema),
+    error: Schema.optional(TestErrorReportSchema),
+});
+export const TestTraceEventSchema = Schema.Struct({
+    name: Schema.String,
+    timestamp: Schema.Number,
+    attributes: Schema.Record(Schema.String, TestValueSchema),
+});
+export const TestTraceLogSchema = Schema.Struct({
+    spanId: Schema.NullOr(Schema.String),
+    timestamp: Schema.Number,
+    level: Schema.Literals(['Fatal', 'Error', 'Warn', 'Info', 'Debug', 'Trace']),
+    message: TestValueSchema,
+    annotations: Schema.Record(Schema.String, TestValueSchema),
+});
+export const TestTraceSpanSchema = Schema.Struct({
+    traceId: Schema.String,
+    spanId: Schema.String,
+    parentSpanId: Schema.NullOr(Schema.String),
+    name: Schema.String,
+    startTime: Schema.Number,
+    // Null/`running` only arise if a span outlives the effect that opened it.
+    // Laymos rejects that at capture time, but the shape stays open so reports
+    // and the recorder agree.
+    endTime: Schema.NullOr(Schema.Number),
+    status: Schema.Literals(['success', 'error', 'running', 'unset']),
+    attributes: Schema.Record(Schema.String, TestValueSchema),
+    events: Schema.Array(TestTraceEventSchema),
+});
+export const LaymosTestEvidenceSchema = Schema.Struct({
+    description: Schema.String,
+    documentation: Schema.optional(Schema.String),
+    assertions: Schema.Array(TestAssertionEvidenceSchema),
+    trace: Schema.optional(Schema.Struct({
+        spans: Schema.Array(TestTraceSpanSchema),
+        logs: Schema.Array(TestTraceLogSchema),
+    })),
+});
+export const TestCaseReportSchema = Schema.Struct({
+    id: Schema.String,
+    name: Schema.String,
+    fullName: Schema.String,
+    status: Schema.Literals(['passed', 'failed', 'skipped', 'pending']),
+    duration: Schema.Number,
+    errors: Schema.Array(TestErrorReportSchema),
+    location: Schema.optional(TestSourceLocationSchema),
+    authoredBy: Schema.optional(Schema.Literal('laymos')),
+    evidence: Schema.optional(LaymosTestEvidenceSchema),
+});
+export const TestSuiteReportSchema = Schema.Struct({
+    id: Schema.String,
+    name: Schema.String,
+    description: Schema.optional(Schema.String),
+    documentation: Schema.optional(Schema.String),
+    status: Schema.Literals(['passed', 'failed', 'skipped', 'pending']),
+    suites: Schema.Array(Schema.suspend(() => TestSuiteReportSchema)),
+    cases: Schema.Array(TestCaseReportSchema),
+    errors: Schema.Array(TestErrorReportSchema),
+});
+export const TestModuleReportSchema = Schema.Struct({
+    id: Schema.String,
+    name: Schema.String,
+    path: Schema.String,
+    projectName: Schema.String,
+    status: Schema.Literals(['passed', 'failed', 'skipped', 'pending']),
+    duration: Schema.Number,
+    suites: Schema.Array(TestSuiteReportSchema),
+    cases: Schema.Array(TestCaseReportSchema),
+    errors: Schema.Array(TestErrorReportSchema),
+});
+export const TestsReportSchema = Schema.Struct({
+    status: Schema.Literals(['passed', 'failed']),
+    duration: Schema.Number,
+    modules: Schema.Array(TestModuleReportSchema),
+    unhandledErrors: Schema.Array(TestErrorReportSchema),
+});

package/dist/services/config/config.d.ts

@@ -0,0 +1,12 @@
+import { Context, Effect, FileSystem, Layer } from 'effect';
+import { type Config } from '../../domain/project-config/index.js';
+import { ConfigError } from './errors.js';
+declare const ConfigService_base: Context.ServiceClass<ConfigService, "ConfigService", {
+    readonly read: (filePath: string) => Effect.Effect<Config, ConfigError>;
+}>;
+export declare class ConfigService extends ConfigService_base {
+    static jsonSchema(): Readonly<Record<string, unknown>>;
+}
+export declare const ConfigServiceLive: Layer.Layer<ConfigService, never, FileSystem.FileSystem>;
+export {};
+//# sourceMappingURL=config.d.ts.map

package/dist/services/config/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/services/config/config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AAE5D,OAAO,EAGL,KAAK,MAAM,EAEZ,MAAM,sCAAsC,CAAC;AAC9C,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;;mBAKvB,CAAC,QAAQ,EAAE,MAAM,KAAK,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC;;AAH3E,qBAAa,aAAc,SAAQ,kBAKf;IAClB,MAAM,CAAC,UAAU,IAAI,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAErD;CACF;AAED,eAAO,MAAM,iBAAiB,0DAyD7B,CAAC"}

package/dist/services/config/config.js

@@ -0,0 +1,46 @@
+import { Context, Effect, FileSystem, Layer } from 'effect';
+import { decodeProjectConfig, projectConfigJsonSchema, validateConfig, } from '../../domain/project-config/index.js';
+import { ConfigError } from './errors.js';
+export class ConfigService extends Context.Service()('ConfigService') {
+    static jsonSchema() {
+        return projectConfigJsonSchema();
+    }
+}
+export const ConfigServiceLive = Layer.effect(ConfigService, Effect.gen(function* () {
+    const fs = yield* FileSystem.FileSystem;
+    return {
+        read: (filePath) => Effect.gen(function* () {
+            const raw = yield* fs.readFileString(filePath).pipe(Effect.mapError((cause) => new ConfigError({
+                reason: 'read',
+                filePath,
+                cause,
+                issues: [],
+            })));
+            const json = yield* Effect.try({
+                try: () => JSON.parse(raw),
+                catch: (cause) => new ConfigError({
+                    reason: 'parse',
+                    filePath,
+                    cause,
+                    issues: [],
+                }),
+            });
+            const decoded = yield* decodeProjectConfig(json).pipe(Effect.mapError((cause) => new ConfigError({
+                reason: 'schema',
+                filePath,
+                cause,
+                issues: [],
+            })));
+            const issues = validateConfig(decoded);
+            if (issues.length > 0) {
+                return yield* new ConfigError({
+                    reason: 'validation',
+                    filePath,
+                    cause: issues,
+                    issues,
+                });
+            }
+            return decoded;
+        }).pipe(Effect.withSpan('config.read')),
+    };
+}));

package/dist/services/config/errors.d.ts

@@ -0,0 +1,13 @@
+import type { ConfigValidationIssue } from '../../domain/project-config/index.js';
+declare const ConfigError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "ConfigError";
+} & Readonly<A>;
+export declare class ConfigError extends ConfigError_base<{
+    readonly reason: 'read' | 'parse' | 'schema' | 'validation';
+    readonly filePath: string;
+    readonly cause: unknown;
+    readonly issues: readonly ConfigValidationIssue[];
+}> {
+}
+export {};
+//# sourceMappingURL=errors.d.ts.map

package/dist/services/config/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/services/config/errors.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,sCAAsC,CAAC;;;;AAElF,qBAAa,WAAY,SAAQ,iBAAgC;IAC/D,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,GAAG,QAAQ,GAAG,YAAY,CAAC;IAC5D,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,MAAM,EAAE,SAAS,qBAAqB,EAAE,CAAC;CACnD,CAAC;CAAG"}

package/dist/services/config/errors.js

@@ -0,0 +1,3 @@
+import { Data } from 'effect';
+export class ConfigError extends Data.TaggedError('ConfigError') {
+}

package/dist/services/config/index.d.ts

@@ -0,0 +1,4 @@
+export { ConfigService } from './config.js';
+export { ConfigServiceLive } from './config.js';
+export { ConfigError } from './errors.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/services/config/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/services/config/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAE5C,OAAO,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAC;AAEhD,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC"}

package/dist/services/config/index.js

@@ -0,0 +1,7 @@
+// Service tag callers yield to obtain the config service. Also exposes the
+// static `jsonSchema()` for the published JSON Schema of laymos.config.json.
+export { ConfigService } from './config.js';
+// Live layer providing ConfigService via the platform FileSystem.
+export { ConfigServiceLive } from './config.js';
+// Tagged error callers pattern-match on when a read fails.
+export { ConfigError } from './errors.js';

package/dist/services/file-cruiser/errors.d.ts

@@ -0,0 +1,10 @@
+declare const CruiseError_base: new <A extends Record<string, any> = {}>(args: import("effect/Types").VoidIfEmpty<{ readonly [P in keyof A as P extends "_tag" ? never : P]: A[P]; }>) => import("effect/Cause").YieldableError & {
+    readonly _tag: "CruiseError";
+} & Readonly<A>;
+export declare class CruiseError extends CruiseError_base<{
+    readonly baseDir: string;
+    readonly cause: unknown;
+}> {
+}
+export {};
+//# sourceMappingURL=errors.d.ts.map

package/dist/services/file-cruiser/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../src/services/file-cruiser/errors.ts"],"names":[],"mappings":";;;AAEA,qBAAa,WAAY,SAAQ,iBAAgC;IAC/D,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;CACzB,CAAC;CAAG"}

package/dist/services/file-cruiser/errors.js

@@ -0,0 +1,3 @@
+import { Data } from 'effect';
+export class CruiseError extends Data.TaggedError('CruiseError') {
+}