laymos 0.0.1

package/dist/story/runner/runner.js

@@ -0,0 +1,476 @@
+import { existsSync } from 'node:fs';
+import { readdir } from 'node:fs/promises';
+import { basename, join, relative, resolve, sep } from 'node:path';
+import { Cause, Context, Data, Duration, Effect, Exit, Layer, Option, Ref, } from 'effect';
+import { createJiti } from 'jiti';
+import { ScenarioRecorder, StoryBlockRegistry, roundMillis, } from '../artifact/index.js';
+import { collectDeclaredStories } from '../core/declare.js';
+import { CurrentRecorder } from '../core/recorder.js';
+export class StoryRunnerError extends Data.TaggedError('StoryRunnerError') {
+}
+export class StoryDiscoveryError extends Data.TaggedError('StoryDiscoveryError') {
+}
+const storyFilePattern = /\.story\.[cm]?[jt]sx?$/;
+const validStoryFile = /^[a-z0-9]+(?:-[a-z0-9]+)*\.story\.(?:[cm]?[jt]sx?)$/;
+const skippedSegments = new Set(['node_modules', 'dist']);
+const defaultTimeout = '60 seconds';
+const storyRuntimePath = resolve(import.meta.dirname, '../story-runtime/index.js');
+export function executeStories(baseDir, filters, options) {
+    return Effect.suspend(() => {
+        enableSourceMaps();
+        return runStoriesGeneration(baseDir, filters, options);
+    }).pipe(Effect.mapError((cause) => storyRunnerError('execute', cause)));
+}
+function runStoriesGeneration(baseDir, filters, options) {
+    return Effect.gen(function* () {
+        const files = filters.length > 0
+            ? [...filters].sort()
+            : yield* discoverStories(baseDir).pipe(Effect.map(({ stories }) => stories.map(({ storyId }) => storyId)));
+        yield* attempt(() => {
+            for (const storyId of files) {
+                validateStoryFile(storyId);
+                if (!existsSync(resolve(baseDir, storyId))) {
+                    throw new Error(`Story file not found: ${storyId}`);
+                }
+            }
+        });
+        const failures = [];
+        const stories = {};
+        for (const storyId of files) {
+            const declarations = yield* fromPromise(() => collectDeclaredStories(() => loadStoryModule(baseDir, storyId)));
+            if (declarations.length !== 1) {
+                return yield* Effect.fail(new Error(`Story file "${storyId}" must declare exactly one Story`));
+            }
+            stories[storyId] = yield* runDeclaredStory(baseDir, storyId, declarations[0], options, failures);
+        }
+        return {
+            status: failures.length === 0 ? 'passed' : 'failed',
+            report: { stories },
+            failures,
+        };
+    });
+}
+function runDeclaredStory(baseDir, storyId, declaration, options, failures) {
+    return Effect.scoped(Effect.gen(function* () {
+        if (declaration.execution === undefined) {
+            return yield* Effect.fail(new Error(`Story "${declaration.name}" must declare one execution`));
+        }
+        const environment = declaration.execution.layer === undefined
+            ? Context.empty()
+            : yield* Layer.build(declaration.execution.layer);
+        const blocks = new StoryBlockRegistry(baseDir);
+        const scenarios = [];
+        for (const declared of declaration.scenarios) {
+            scenarios.push(yield* runScenario(storyId, declaration, declared, blocks, environment, options, failures));
+        }
+        return {
+            schemaVersion: 3,
+            generatedAt: Date.now(),
+            name: declaration.name,
+            description: declaration.description,
+            blocks: blocks.toRecord(),
+            scenarios,
+        };
+    }));
+}
+function runScenario(storyId, story, declared, blocks, environment, options, failures) {
+    const base = {
+        name: declared.name,
+        description: declared.description,
+        location: {
+            file: storyId,
+            line: declared.location.line,
+            column: declared.location.column,
+        },
+    };
+    if (declared.mode === 'skip') {
+        return Effect.succeed({
+            ...base,
+            outcome: 'skipped',
+            execution: [],
+            failures: [],
+        });
+    }
+    const recorder = new ScenarioRecorder(blocks);
+    const startedAt = Date.now();
+    const startMonotonic = performance.now();
+    const scenarioEnvironment = Context.add(environment, CurrentRecorder, recorder);
+    return runScenarioLifecycle(story, declared, recorder, scenarioEnvironment, options).pipe(Effect.ensuring(Effect.sync(() => recorder.close())), Effect.map((result) => {
+        const durationMillis = roundMillis(performance.now() - startMonotonic);
+        for (const failure of result.failures) {
+            failures.push({
+                storyId,
+                scenario: declared.name,
+                phase: failure.phase,
+                message: failure.message,
+            });
+        }
+        return {
+            ...base,
+            outcome: result.outcome,
+            startedAt,
+            durationMillis,
+            execution: recorder.execution(),
+            failures: result.failures,
+        };
+    }));
+}
+function runScenarioLifecycle(story, scenario, recorder, environment, options) {
+    const execution = story.execution;
+    if (execution === undefined) {
+        return Effect.fail(new Error(`Story "${story.name}" has no execution`));
+    }
+    const timeout = (scenario.run.timeout ??
+        options?.timeout ??
+        defaultTimeout);
+    return Effect.gen(function* () {
+        const progress = yield* Ref.make({
+            phase: 'preparation',
+            failures: [],
+            interrupted: false,
+        });
+        const lifecycleExit = yield* runEffectLifecycle(execution, scenario.run, recorder, progress).pipe(Effect.provide(environment), Effect.timeout(timeout), Effect.exit);
+        if (Exit.isSuccess(lifecycleExit))
+            return lifecycleExit.value;
+        if (!isTimeoutCause(lifecycleExit.cause)) {
+            return yield* Effect.failCause(lifecycleExit.cause);
+        }
+        const current = yield* Ref.get(progress);
+        return {
+            outcome: 'interrupted',
+            failures: [
+                ...current.failures,
+                { phase: current.phase, message: timeoutMessage(timeout) },
+            ],
+        };
+    });
+}
+function runEffectLifecycle(execution, run, recorder, progress) {
+    return Effect.gen(function* () {
+        const prepareExit = yield* runEffectPhase(run.prepare).pipe(Effect.exit);
+        if (Exit.isFailure(prepareExit)) {
+            yield* recordPhaseFailure(progress, 'preparation', prepareExit.cause);
+            return yield* scenarioResult(progress);
+        }
+        const prepared = prepareExit.value;
+        const body = Effect.gen(function* () {
+            yield* setPhase(progress, 'execution');
+            const executionExit = yield* Effect.acquireUseRelease(Effect.sync(() => recorder.activate()), () => runEffectPhase(() => execution.execute(prepared)).pipe(Effect.exit), () => Effect.sync(() => recorder.deactivate()));
+            if (Exit.isFailure(executionExit) &&
+                Cause.hasInterruptsOnly(executionExit.cause)) {
+                yield* recordPhaseFailure(progress, 'execution', executionExit.cause, 'Story execution was interrupted');
+                return;
+            }
+            const verification = expectedVerification(run.expectation, executionExit, prepared);
+            if (verification.kind === 'mismatch') {
+                yield* addFailure(progress, {
+                    phase: 'execution',
+                    message: verification.message,
+                });
+                return;
+            }
+            yield* setPhase(progress, 'verification');
+            const verificationExit = yield* runEffectPhase(verification.verify).pipe(Effect.exit);
+            if (Exit.isFailure(verificationExit)) {
+                yield* recordPhaseFailure(progress, 'verification', verificationExit.cause);
+            }
+        });
+        yield* Effect.onExitPrimitive(body, (bodyExit) => runCleanup(run, prepared, progress, bodyExit), true);
+        return yield* scenarioResult(progress);
+    });
+}
+function runEffectPhase(phase) {
+    return Effect.suspend(phase);
+}
+function expectedVerification(expectation, executionExit, prepared) {
+    if (expectation.kind === 'success') {
+        return Exit.isSuccess(executionExit)
+            ? {
+                kind: 'verify',
+                verify: () => expectation.verify(executionExit.value, prepared),
+            }
+            : {
+                kind: 'mismatch',
+                message: `Expected a success value but execution failed: ${describeFailure(Cause.squash(executionExit.cause))}`,
+            };
+    }
+    if (Exit.isSuccess(executionExit)) {
+        return {
+            kind: 'mismatch',
+            message: 'Expected a typed error but execution succeeded',
+        };
+    }
+    if (Cause.hasDies(executionExit.cause) ||
+        Cause.hasInterrupts(executionExit.cause)) {
+        return {
+            kind: 'mismatch',
+            message: `Expected a typed error but execution terminated unexpectedly: ${describeFailure(Cause.squash(executionExit.cause))}`,
+        };
+    }
+    const error = Cause.findErrorOption(executionExit.cause);
+    return Option.isSome(error)
+        ? {
+            kind: 'verify',
+            verify: () => expectation.verify(error.value, prepared),
+        }
+        : {
+            kind: 'mismatch',
+            message: 'Expected a typed error but execution produced none',
+        };
+}
+function runCleanup(run, prepared, progress, bodyExit) {
+    if (run.cleanup === undefined)
+        return Effect.void;
+    return Effect.gen(function* () {
+        if (Exit.isSuccess(bodyExit) || !Cause.hasInterruptsOnly(bodyExit.cause)) {
+            yield* setPhase(progress, 'cleanup');
+        }
+        const cleanupExit = yield* runEffectPhase(() => run.cleanup(prepared)).pipe(Effect.exit);
+        if (Exit.isFailure(cleanupExit)) {
+            yield* recordPhaseFailure(progress, 'cleanup', cleanupExit.cause);
+        }
+    });
+}
+function setPhase(progress, phase) {
+    return Ref.update(progress, (current) => ({ ...current, phase }));
+}
+function addFailure(progress, failure, interrupted = false) {
+    return Ref.update(progress, (current) => ({
+        ...current,
+        failures: [...current.failures, failure],
+        interrupted: current.interrupted || interrupted,
+    }));
+}
+function recordPhaseFailure(progress, phase, cause, interruptionMessage) {
+    const interrupted = Cause.hasInterruptsOnly(cause);
+    return addFailure(progress, {
+        phase,
+        message: interrupted && interruptionMessage !== undefined
+            ? interruptionMessage
+            : describeFailure(Cause.squash(cause)),
+    }, interrupted);
+}
+function scenarioResult(progress) {
+    return Ref.get(progress).pipe(Effect.map((current) => ({
+        outcome: current.interrupted
+            ? 'interrupted'
+            : current.failures.length === 0
+                ? 'succeeded'
+                : 'failed',
+        failures: current.failures,
+    })));
+}
+function isTimeoutCause(cause) {
+    const error = Cause.findErrorOption(cause);
+    return Option.isSome(error) && Cause.isTimeoutError(error.value);
+}
+async function loadStoryModule(baseDir, storyId) {
+    const path = resolve(baseDir, storyId);
+    const jiti = createJiti(import.meta.url, {
+        alias: { 'laymos/story': storyRuntimePath },
+        interopDefault: true,
+        moduleCache: false,
+    });
+    await jiti.import(path);
+}
+export function discoverStories(baseDir) {
+    return Effect.tryPromise({
+        try: () => buildStoryCatalog(baseDir),
+        catch: (cause) => cause instanceof StoryDiscoveryError
+            ? cause
+            : discoveryError([{ message: errorMessage(cause) }]),
+    });
+}
+async function buildStoryCatalog(baseDir) {
+    const { storyIds, issues } = await discoverStoryFileIds(baseDir);
+    const declarations = [];
+    for (const storyId of storyIds) {
+        try {
+            const found = await collectDeclaredStories(() => loadStoryModule(baseDir, storyId));
+            if (found.length !== 1) {
+                issues.push({
+                    storyId,
+                    message: `must declare exactly one Story; found ${found.length}`,
+                });
+                continue;
+            }
+            declarations.push({ storyId, declaration: found[0] });
+        }
+        catch (cause) {
+            issues.push({ storyId, message: errorMessage(cause) });
+        }
+    }
+    const catalog = validateStoryCatalog(declarations, issues);
+    if (issues.length > 0)
+        throw discoveryError(issues);
+    return catalog;
+}
+async function discoverStoryFileIds(baseDir) {
+    const storyIds = [];
+    const issues = [];
+    const directories = [baseDir];
+    while (directories.length > 0) {
+        const directory = directories.pop();
+        const entries = await readdir(directory, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isDirectory()) {
+                if (skippedSegments.has(entry.name) || entry.name.startsWith('.')) {
+                    continue;
+                }
+                directories.push(join(directory, entry.name));
+                continue;
+            }
+            if (!entry.isFile() || !storyFilePattern.test(entry.name))
+                continue;
+            const storyId = relative(baseDir, join(directory, entry.name))
+                .split(sep)
+                .join('/');
+            storyIds.push(storyId);
+            try {
+                validateStoryFile(storyId);
+            }
+            catch (cause) {
+                issues.push({ storyId, message: errorMessage(cause) });
+            }
+        }
+    }
+    storyIds.sort();
+    return { storyIds, issues };
+}
+function validateStoryCatalog(declarations, issues) {
+    const groups = new Map();
+    const stories = [];
+    const destinations = new Map();
+    const registerDestination = (parentPath, name, kind, storyId) => {
+        const siblings = destinations.get(pathKey(parentPath)) ?? new Map();
+        destinations.set(pathKey(parentPath), siblings);
+        const existing = siblings.get(name);
+        if (existing === undefined) {
+            siblings.set(name, { kind, storyId });
+            return;
+        }
+        if (kind === 'Group' && existing.kind === 'Group')
+            return;
+        issues.push({
+            storyId,
+            message: `${kind} "${displayPath([...parentPath, name])}" conflicts with ${existing.kind} declared by "${existing.storyId}"`,
+        });
+    };
+    for (const { storyId, declaration } of declarations) {
+        const lineage = storyGroupLineage(declaration.group, storyId, issues);
+        const groupPath = [];
+        for (const group of lineage) {
+            const parentPath = [...groupPath];
+            groupPath.push(group.name);
+            const key = pathKey(groupPath);
+            const existing = groups.get(key);
+            if (existing === undefined) {
+                groups.set(key, {
+                    path: [...groupPath],
+                    name: group.name,
+                    description: group.description,
+                    storyId,
+                });
+            }
+            else if (existing.description !== group.description) {
+                issues.push({
+                    storyId,
+                    message: `Story Group "${displayPath(groupPath)}" conflicts with metadata declared by "${existing.storyId}"`,
+                });
+            }
+            registerDestination(parentPath, group.name, 'Group', storyId);
+        }
+        registerDestination(groupPath, declaration.name, 'Story', storyId);
+        stories.push({
+            storyId,
+            name: declaration.name,
+            description: declaration.description,
+            groupPath,
+        });
+    }
+    return {
+        groups: [...groups.values()]
+            .map(({ storyId: _storyId, ...group }) => group)
+            .sort((left, right) => comparePaths(left.path, right.path)),
+        stories: stories.sort((left, right) => comparePaths(left.groupPath, right.groupPath) ||
+            left.name.localeCompare(right.name) ||
+            left.storyId.localeCompare(right.storyId)),
+    };
+}
+function storyGroupLineage(leaf, storyId, issues) {
+    const reversed = [];
+    const seen = new Set();
+    let current = leaf;
+    while (current !== undefined) {
+        if (seen.has(current)) {
+            issues.push({
+                storyId,
+                message: 'Story Group ancestry contains a cycle',
+            });
+            return [];
+        }
+        seen.add(current);
+        reversed.push(current);
+        current = current.parent;
+    }
+    return reversed.reverse();
+}
+const pathKey = (path) => JSON.stringify(path);
+const displayPath = (path) => path.join(' / ');
+function comparePaths(left, right) {
+    for (let index = 0; index < Math.min(left.length, right.length); index++) {
+        const compared = left[index].localeCompare(right[index]);
+        if (compared !== 0)
+            return compared;
+    }
+    return left.length - right.length;
+}
+function discoveryError(issues) {
+    const details = issues.map(({ storyId, message }) => `- ${storyId === undefined ? message : `${storyId}: ${message}`}`);
+    return new StoryDiscoveryError({
+        message: `Story catalog is invalid:\n${details.join('\n')}`,
+        issues,
+    });
+}
+function validateStoryFile(storyId) {
+    if (!validStoryFile.test(basename(storyId))) {
+        throw new Error(`Story file "${storyId}" must use the kebab-case <story-name>.story.ts convention`);
+    }
+}
+function timeoutMessage(timeout) {
+    const millis = typeof timeout === 'number' ? timeout : Duration.toMillis(timeout);
+    return `Scenario timed out after ${millis}ms`;
+}
+function describeFailure(failure) {
+    if (failure instanceof Error)
+        return failure.message;
+    if (typeof failure === 'string')
+        return failure;
+    return String(failure);
+}
+function errorMessage(cause) {
+    return cause instanceof Error ? cause.message : String(cause);
+}
+function enableSourceMaps() {
+    try {
+        process.setSourceMapsEnabled(true);
+    }
+    catch {
+        // best-effort; some runtimes do not implement it
+    }
+}
+function fromPromise(body) {
+    return Effect.tryPromise({ try: body, catch: (cause) => cause });
+}
+function attempt(body) {
+    return Effect.try({ try: body, catch: (cause) => cause });
+}
+function storyRunnerError(operation, cause) {
+    if (cause instanceof StoryRunnerError)
+        return cause;
+    return new StoryRunnerError({
+        operation,
+        message: describeFailure(cause),
+        cause,
+    });
+}

package/dist/story/story-runtime/index.d.ts

@@ -0,0 +1,2 @@
+export { decision, functionBlock, step, story, storyGroup, } from './story-runtime.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/story/story-runtime/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/story/story-runtime/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,QAAQ,EACR,aAAa,EACb,IAAI,EACJ,KAAK,EACL,UAAU,GACX,MAAM,oBAAoB,CAAC"}

package/dist/story/story-runtime/index.js

@@ -0,0 +1 @@
+export { decision, functionBlock, step, story, storyGroup, } from './story-runtime.js';

package/dist/story/story-runtime/story-runtime.d.ts

@@ -0,0 +1,52 @@
+import { Effect } from 'effect';
+import type { Duration, Layer } from 'effect';
+import type { ArmMeta, BlockMeta, DecisionValue, StoryGroupMeta, StoryMeta } from '../core/types.js';
+export interface ScenarioMeta {
+    readonly description: string;
+    readonly timeout?: Duration.Input;
+}
+export interface EffectVerifiedScenario<Prepared, R> {
+    cleanup<E>(cleanup: (prepared: Prepared) => Effect.Effect<unknown, E, R>): EffectVerifiedScenario<Prepared, R>;
+}
+export interface EffectPreparedScenario<Prepared, Output, Error, R> {
+    cleanup<CleanupError>(cleanup: (prepared: Prepared) => Effect.Effect<unknown, CleanupError, R>): EffectPreparedScenario<Prepared, Output, Error, R>;
+    verify<VerificationError>(verify: (output: Output, prepared: Prepared) => Effect.Effect<unknown, VerificationError, R>): EffectVerifiedScenario<Prepared, R>;
+    verifyError<VerificationError>(verify: (error: Error, prepared: Prepared) => Effect.Effect<unknown, VerificationError, R>): EffectVerifiedScenario<Prepared, R>;
+}
+export interface EffectScenario<Prepared, Output, Error, R> {
+    prepare<PreparationError>(prepare: () => Effect.Effect<Prepared, PreparationError, R>): EffectPreparedScenario<Prepared, Output, Error, R>;
+}
+export interface EffectStory<Prepared, Output, Error, R> {
+    scenario(name: string, meta: ScenarioMeta, define: (scenario: EffectScenario<Prepared, Output, Error, R>) => EffectVerifiedScenario<Prepared, R>): EffectStory<Prepared, Output, Error, R>;
+    skip(name: string, meta: ScenarioMeta): EffectStory<Prepared, Output, Error, R>;
+}
+export interface EffectStoryBuilder<R> {
+    provide<Services, LayerError>(layer: Layer.Layer<Services, LayerError, never>): EffectStoryBuilder<Services>;
+    execute<Prepared, Output, Error>(execute: (prepared: Prepared) => Effect.Effect<Output, Error, R>): EffectStory<Prepared, Output, Error, R>;
+}
+export interface EffectStoryGroup {
+    group(name: string, meta: StoryGroupMeta): EffectStoryGroup;
+    story(name: string, meta: StoryMeta): EffectStoryBuilder<never>;
+}
+/** Declares the single Story owned by a Story file. */
+export declare function story(name: string, meta: StoryMeta): EffectStoryBuilder<never>;
+/** Declares a reusable Story Group. */
+export declare function storyGroup(name: string, meta: StoryGroupMeta): EffectStoryGroup;
+type AnyEffect = Effect.Effect<any, any, any>;
+type Success<T> = T extends Effect.Effect<infer A, any, any> ? A : never;
+type Error<T> = T extends Effect.Effect<any, infer E, any> ? E : never;
+type Services<T> = T extends Effect.Effect<any, any, infer R> ? R : never;
+export interface DecisionBuilder<Remaining extends DecisionValue, A, E, R> {
+    when<Key extends Remaining, Next extends AnyEffect>(value: Key, meta: ArmMeta, body: (value: Key) => Next): DecisionBuilder<Exclude<Remaining, Key>, A | Success<Next>, E | Error<Next>, R | Services<Next>>;
+    otherwise<Next extends AnyEffect>(meta: ArmMeta, body: (value: Remaining) => Next): Effect.Effect<A | Success<Next>, E | Error<Next>, R | Services<Next>>;
+    readonly exhaustive: [Remaining] extends [never] ? () => Effect.Effect<A, E, R> : never;
+    [Symbol.iterator](): Effect.EffectIterator<Effect.Effect<A, E, R>>;
+}
+/** Marks a reusable Effect-returning function boundary as a Story Block. */
+export declare function functionBlock<Args extends readonly unknown[], A, E, R>(name: string, meta: BlockMeta<Args>, fn: (...args: Args) => Effect.Effect<A, E, R>): (...args: Args) => Effect.Effect<A, E, R>;
+/** Wraps an Effect in an inline Story Block. */
+export declare function step<A, E, R>(name: string, meta: BlockMeta, effect: Effect.Effect<A, E, R>): Effect.Effect<A, E, R>;
+/** Builds an eager, literal-keyed Effect Decision. */
+export declare function decision<const Input extends DecisionValue>(name: string, meta: BlockMeta<[Input]>, input: Input): DecisionBuilder<Input, never, never, never>;
+export {};
+//# sourceMappingURL=story-runtime.d.ts.map

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

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