laymos 0.0.1 → 0.0.3

package/dist/orchestrator/run-stories/run-stories.js

@@ -0,0 +1,290 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join, relative, resolve, sep } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { Cause, Effect, Exit, Stream } from 'effect';
+import { NodeServices } from '@effect/platform-node';
+import { tsImport } from 'tsx/esm/api';
+import { isStory, isStoryGroup, StoryContext, } from '../../story/index.js';
+import { slugifyQuestion } from '../../story/schema/index.js';
+import { ConfigService, ConfigServiceLive, } from '../../services/config/index.js';
+import { extractSnippets, storySnippets, } from './extract-snippets.js';
+import { StoriesError } from './errors.js';
+export function getStoryTree(configPath) {
+    return Effect.map(loadRoot(configPath), ({ tree }) => tree);
+}
+const DEFAULT_CONCURRENCY = 16;
+export function planStories(configPath, options) {
+    return Effect.gen(function* () {
+        const { stories } = yield* loadRoot(configPath);
+        const planned = yield* scopeStories(stories, options?.scope);
+        return {
+            total: planned.length,
+            reports: runEachStory(planned, options?.concurrency ?? DEFAULT_CONCURRENCY),
+        };
+    });
+}
+export function runStories(configPath, options) {
+    return Stream.unwrap(Effect.map(planStories(configPath, options), ({ reports }) => reports));
+}
+function runEachStory(stories, concurrency) {
+    // Ordered concurrent mapping needs three slots; anything less runs one at a time.
+    return Stream.fromArray(stories).pipe(Stream.mapEffect(runStory, concurrency >= 3 ? { concurrency } : undefined));
+}
+function scopeStories(stories, scope) {
+    if (scope === undefined)
+        return Effect.succeed(stories);
+    const scoped = stories.filter(({ id }) => id === scope || id.startsWith(`${scope}/`));
+    if (scoped.length === 0) {
+        return Effect.fail(new StoriesError({ reason: 'unknown-scope', path: scope, cause: null }));
+    }
+    return Effect.succeed(scoped);
+}
+function loadRoot(configPath) {
+    return Effect.gen(function* () {
+        const absoluteConfigPath = resolve(configPath);
+        const configService = yield* ConfigService;
+        const config = yield* configService.read(absoluteConfigPath);
+        if (config.storiesPath === undefined) {
+            return yield* new StoriesError({
+                reason: 'no-stories-path',
+                path: absoluteConfigPath,
+                cause: null,
+            });
+        }
+        const storiesRoot = join(dirname(absoluteConfigPath), config.storiesPath);
+        const entryPoint = join(storiesRoot, 'index.ts');
+        const barrel = yield* Effect.tryPromise({
+            try: () => tsImport(entryPoint, import.meta.url),
+            catch: (cause) => new StoriesError({ reason: 'load', path: entryPoint, cause }),
+        });
+        const root = barrel.default;
+        if (!isStoryGroup(root)) {
+            return yield* new StoriesError({
+                reason: 'invalid-root',
+                path: entryPoint,
+                cause: null,
+            });
+        }
+        return yield* indexGroup(root, [root.title], entryPoint, {
+            projectRoot: dirname(absoluteConfigPath),
+            storiesRoot,
+            supportCache: new Map(),
+        });
+    }).pipe(Effect.provide(ConfigServiceLive), Effect.provide(NodeServices.layer));
+}
+function indexGroup(group, path, entryPoint, options) {
+    return Effect.gen(function* () {
+        yield* checkUniqueTitles(group.children, path, entryPoint);
+        const groups = [];
+        const leaves = [];
+        const stories = [];
+        for (const child of group.children) {
+            const id = [...path, child.title].join('/');
+            if (isStory(child)) {
+                const source = yield* loadStorySource(child, options.projectRoot);
+                const snippets = extractSnippets(source.path, source.content);
+                const questions = yield* indexQuestions(child, source, storySnippets(snippets, child.title));
+                leaves.push({
+                    id,
+                    title: child.title,
+                    setup: snippets.setup,
+                    questions,
+                    source,
+                    support: resolveSupport(child, options),
+                });
+                stories.push({ id, story: child });
+            }
+            else {
+                const indexed = yield* indexGroup(child, [...path, child.title], entryPoint, options);
+                groups.push(indexed.tree);
+                stories.push(...indexed.stories);
+            }
+        }
+        return {
+            tree: { title: group.title, groups, stories: leaves },
+            stories,
+        };
+    });
+}
+function indexQuestions(story, source, snippets) {
+    return Effect.gen(function* () {
+        const seen = new Set();
+        const leaves = [];
+        for (const [index, question] of story.questions.entries()) {
+            const slug = slugifyQuestion(question.question);
+            if (seen.has(slug)) {
+                return yield* new StoriesError({
+                    reason: 'duplicate-question',
+                    path: source.path,
+                    cause: question.question,
+                });
+            }
+            seen.add(slug);
+            const snippet = snippets.proofs.get(question.question) ?? snippets.orderedProofs[index];
+            if (snippet === undefined) {
+                return yield* new StoriesError({
+                    reason: 'snippet-extraction',
+                    path: source.path,
+                    cause: question.question,
+                });
+            }
+            leaves.push({
+                slug,
+                question: question.question,
+                answer: question.answer,
+                snippet,
+            });
+        }
+        return leaves;
+    });
+}
+function loadStorySource(story, projectRoot) {
+    return Effect.try({
+        try: () => {
+            const filePath = fileURLToPath(story.sourceUrl);
+            return {
+                path: relative(projectRoot, filePath),
+                content: readFileSync(filePath, 'utf8'),
+            };
+        },
+        catch: (cause) => new StoriesError({ reason: 'load', path: story.sourceUrl, cause }),
+    });
+}
+const SUPPORT_FILE = 'support.ts';
+function resolveSupport(story, options) {
+    const { projectRoot, storiesRoot, supportCache } = options;
+    let directory;
+    try {
+        directory = dirname(fileURLToPath(story.sourceUrl));
+    }
+    catch {
+        return null;
+    }
+    const root = resolve(storiesRoot);
+    const visited = [];
+    let found = null;
+    while (directory === root || directory.startsWith(`${root}${sep}`)) {
+        const cached = supportCache.get(directory);
+        if (cached !== undefined) {
+            found = cached;
+            break;
+        }
+        visited.push(directory);
+        const candidate = join(directory, SUPPORT_FILE);
+        if (existsSync(candidate)) {
+            found = {
+                path: relative(projectRoot, candidate),
+                content: readFileSync(candidate, 'utf8'),
+            };
+            break;
+        }
+        directory = dirname(directory);
+    }
+    for (const cachedDirectory of visited) {
+        supportCache.set(cachedDirectory, found);
+    }
+    return found;
+}
+function checkUniqueTitles(children, path, entryPoint) {
+    const seen = new Set();
+    for (const child of children) {
+        if (seen.has(child.title)) {
+            return new StoriesError({
+                reason: 'duplicate-title',
+                path: entryPoint,
+                cause: [...path, child.title].join('/'),
+            });
+        }
+        seen.add(child.title);
+    }
+    return Effect.void;
+}
+function runStory({ id, story }) {
+    return Effect.gen(function* () {
+        const questions = [];
+        for (const question of story.questions) {
+            questions.push(yield* runQuestion(question));
+        }
+        const verdict = questions.some(({ verdict }) => verdict === 'errored')
+            ? 'errored'
+            : questions.some(({ verdict }) => verdict === 'failed')
+                ? 'failed'
+                : 'passed';
+        return { id, verdict, questions };
+    });
+}
+function runQuestion(question) {
+    return Effect.gen(function* () {
+        const sections = [];
+        const assertions = [];
+        const exit = yield* question.proof.pipe(Effect.provideService(StoryContext, {
+            beginSection: (section) => Effect.sync(() => {
+                sections.push(section);
+            }),
+            assert: (description, passed) => Effect.sync(() => {
+                assertions.push({ description, passed });
+            }),
+        }), Effect.exit);
+        const slug = slugifyQuestion(question.question);
+        if (Exit.isFailure(exit)) {
+            return {
+                slug,
+                verdict: 'errored',
+                error: Cause.pretty(exit.cause),
+                assertions,
+                sections,
+            };
+        }
+        const failed = assertions.some((assertion) => !assertion.passed);
+        return {
+            slug,
+            verdict: failed ? 'failed' : 'passed',
+            result: toJsonValue(exit.value),
+            assertions,
+            sections,
+        };
+    });
+}
+function toJsonValue(value, ancestors = new Set()) {
+    if (value === null || value === undefined)
+        return null;
+    switch (typeof value) {
+        case 'string':
+            return value;
+        case 'number':
+            return Number.isFinite(value) ? value : String(value);
+        case 'boolean':
+            return value;
+        case 'bigint':
+        case 'function':
+        case 'symbol':
+            return String(value);
+    }
+    const object = value;
+    if (ancestors.has(object))
+        return '[circular]';
+    ancestors.add(object);
+    const json = toJsonObject(object, ancestors);
+    ancestors.delete(object);
+    return json;
+}
+function toJsonObject(object, ancestors) {
+    if (Array.isArray(object)) {
+        return object.map((item) => toJsonValue(item, ancestors));
+    }
+    if (object instanceof Date)
+        return object.toISOString();
+    if (object instanceof Map) {
+        return [...object.entries()].map(([key, item]) => [
+            toJsonValue(key, ancestors),
+            toJsonValue(item, ancestors),
+        ]);
+    }
+    if (object instanceof Set) {
+        return [...object.values()].map((item) => toJsonValue(item, ancestors));
+    }
+    return Object.fromEntries(Object.entries(object).map(([key, item]) => [
+        key,
+        toJsonValue(item, ancestors),
+    ]));
+}

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') {
+}

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

@@ -0,0 +1,11 @@
+import { Context, Effect, Layer } from 'effect';
+import type { FileGraph } from '../../domain/file-graph/index.js';
+import type { CruiseError } from './errors.js';
+declare const Cruiser_base: Context.ServiceClass<Cruiser, "Cruiser", {
+    readonly cruise: (baseDir: string, sourceRoots: readonly string[], ignoredPaths?: readonly string[]) => Effect.Effect<FileGraph, CruiseError>;
+}>;
+export declare class Cruiser extends Cruiser_base {
+}
+export declare const CruiserLive: Layer.Layer<Cruiser, never, never>;
+export {};
+//# sourceMappingURL=file-cruiser.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"file-cruiser.d.ts","sourceRoot":"","sources":["../../../src/services/file-cruiser/file-cruiser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAAQ,CAAC;AAEhD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAClE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;;qBAM1B,CACf,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,SAAS,MAAM,EAAE,EAC9B,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,KAC7B,MAAM,CAAC,MAAM,CAAC,SAAS,EAAE,WAAW,CAAC;;AAP9C,qBAAa,OAAQ,SAAQ,YASf;CAAG;AAEjB,eAAO,MAAM,WAAW,oCAGtB,CAAC"}

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

@@ -0,0 +1,7 @@
+import { Context, Layer } from 'effect';
+import { buildFileGraph } from './oxc/index.js';
+export class Cruiser extends Context.Service()('Cruiser') {
+}
+export const CruiserLive = Layer.succeed(Cruiser)({
+    cruise: (baseDir, sourceRoots, ignoredPaths = []) => buildFileGraph(baseDir, sourceRoots, ignoredPaths),
+});

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

@@ -0,0 +1,4 @@
+export { Cruiser } from './file-cruiser.js';
+export { CruiserLive } from './file-cruiser.js';
+export { CruiseError } from './errors.js';
+//# sourceMappingURL=index.d.ts.map

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

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

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

@@ -0,0 +1,6 @@
+// Service tag callers yield to obtain the cruiser.
+export { Cruiser } from './file-cruiser.js';
+// Live layer providing Cruiser via oxc-parser/oxc-resolver.
+export { CruiserLive } from './file-cruiser.js';
+// Tagged error callers pattern-match on when a cruise fails.
+export { CruiseError } from './errors.js';

package/dist/services/file-cruiser/oxc/file-scanner.d.ts

@@ -0,0 +1,5 @@
+export declare const sourceExtensions: string[];
+export declare function listSourceFiles(baseDir: string, sourceRoots: readonly string[]): Promise<string[]>;
+export declare function pathContains(parent: string, child: string): boolean;
+export declare function toPosixPath(path: string): string;
+//# sourceMappingURL=file-scanner.d.ts.map

package/dist/services/file-cruiser/oxc/file-scanner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-scanner.d.ts","sourceRoot":"","sources":["../../../../src/services/file-cruiser/oxc/file-scanner.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,gBAAgB,UAAiD,CAAC;AAE/E,wBAAsB,eAAe,CACnC,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,SAAS,MAAM,EAAE,GAC7B,OAAO,CAAC,MAAM,EAAE,CAAC,CAsBnB;AAED,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAEnE;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEhD"}

package/dist/services/file-cruiser/oxc/file-scanner.js

@@ -0,0 +1,54 @@
+import { readdir, stat } from 'node:fs/promises';
+import { relative, resolve, sep } from 'node:path';
+import { Schema } from 'effect';
+const MissingFileErrorSchema = Schema.Struct({
+    code: Schema.Literal('ENOENT'),
+});
+export const sourceExtensions = ['.ts', '.tsx', '.js', '.jsx', '.mjs', '.cjs'];
+export async function listSourceFiles(baseDir, sourceRoots) {
+    const files = new Set();
+    for (const sourceRoot of sourceRoots) {
+        const absolute = resolve(baseDir, sourceRoot);
+        const sourceRootStat = await statOrUndefined(absolute);
+        if (sourceRootStat?.isFile()) {
+            if (isSupportedSourceFile(sourceRoot))
+                files.add(sourceRoot);
+            continue;
+        }
+        if (!sourceRootStat?.isDirectory())
+            continue;
+        const entries = await readdir(absolute, {
+            recursive: true,
+            withFileTypes: true,
+        });
+        for (const entry of entries) {
+            if (!entry.isFile() || !isSupportedSourceFile(entry.name))
+                continue;
+            files.add(toPosixPath(relative(baseDir, resolve(entry.parentPath, entry.name))));
+        }
+    }
+    return [...files].sort();
+}
+export function pathContains(parent, child) {
+    return parent === '.' || child === parent || child.startsWith(`${parent}/`);
+}
+export function toPosixPath(path) {
+    return sep === '/' ? path : path.split(sep).join('/');
+}
+async function statOrUndefined(path) {
+    try {
+        return await stat(path);
+    }
+    catch (cause) {
+        if (Schema.is(MissingFileErrorSchema)(cause)) {
+            return undefined;
+        }
+        throw cause;
+    }
+}
+function isSupportedSourceFile(path) {
+    return (sourceExtensions.some((extension) => path.endsWith(extension)) &&
+        !path.endsWith('.d.ts') &&
+        !/\.(?:test|spec)\.[cm]?[jt]sx?$/.test(path) &&
+        !/\.min\.(?:[cm]?js|jsx)$/.test(path));
+}

package/dist/services/file-cruiser/oxc/import-resolver.d.ts

@@ -0,0 +1,5 @@
+import { ResolverFactory } from 'oxc-resolver';
+export declare function createResolver(): ResolverFactory;
+export declare function extractSpecifiers(absolutePath: string): Promise<string[]>;
+export declare function resolveSpecifier(resolver: ResolverFactory, baseDir: string, eligible: ReadonlySet<string>, fromFile: string, specifier: string): string | undefined;
+//# sourceMappingURL=import-resolver.d.ts.map

package/dist/services/file-cruiser/oxc/import-resolver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"import-resolver.d.ts","sourceRoot":"","sources":["../../../../src/services/file-cruiser/oxc/import-resolver.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAI/C,wBAAgB,cAAc,IAAI,eAAe,CAWhD;AAED,wBAAsB,iBAAiB,CACrC,YAAY,EAAE,MAAM,GACnB,OAAO,CAAC,MAAM,EAAE,CAAC,CAenB;AAED,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,eAAe,EACzB,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,WAAW,CAAC,MAAM,CAAC,EAC7B,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,MAAM,GAChB,MAAM,GAAG,SAAS,CAUpB"}

package/dist/services/file-cruiser/oxc/import-resolver.js

@@ -0,0 +1,44 @@
+import { readFile } from 'node:fs/promises';
+import { relative, sep } from 'node:path';
+import { parseSync } from 'oxc-parser';
+import { ResolverFactory } from 'oxc-resolver';
+import { sourceExtensions, toPosixPath } from './file-scanner.js';
+export function createResolver() {
+    return new ResolverFactory({
+        tsconfig: 'auto',
+        extensions: sourceExtensions,
+        extensionAlias: {
+            '.js': ['.ts', '.tsx', '.js'],
+            '.jsx': ['.tsx', '.jsx'],
+            '.mjs': ['.mts', '.mjs'],
+            '.cjs': ['.cts', '.cjs'],
+        },
+    });
+}
+export async function extractSpecifiers(absolutePath) {
+    const sourceText = await readFile(absolutePath, 'utf8');
+    const result = parseSync(absolutePath, sourceText);
+    const specifiers = [];
+    for (const staticImport of result.module.staticImports) {
+        specifiers.push(staticImport.moduleRequest.value);
+    }
+    for (const staticExport of result.module.staticExports) {
+        for (const entry of staticExport.entries) {
+            if (entry.moduleRequest !== null) {
+                specifiers.push(entry.moduleRequest.value);
+            }
+        }
+    }
+    return specifiers;
+}
+export function resolveSpecifier(resolver, baseDir, eligible, fromFile, specifier) {
+    const result = resolver.resolveFileSync(fromFile, specifier);
+    if (result.builtin !== undefined || result.path === undefined) {
+        return undefined;
+    }
+    if (result.path.split(sep).includes('node_modules')) {
+        return undefined;
+    }
+    const relativePath = toPosixPath(relative(baseDir, result.path));
+    return eligible.has(relativePath) ? relativePath : undefined;
+}

package/dist/services/file-cruiser/oxc/index.d.ts

@@ -0,0 +1,2 @@
+export { buildFileGraph } from './oxc.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/services/file-cruiser/oxc/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/services/file-cruiser/oxc/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC"}

package/dist/services/file-cruiser/oxc/index.js

@@ -0,0 +1,2 @@
+// Builds the raw file-dependency graph using oxc-parser and oxc-resolver.
+export { buildFileGraph } from './oxc.js';

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

@@ -0,0 +1,5 @@
+import { Effect } from 'effect';
+import type { FileGraph } from '../../../domain/file-graph/index.js';
+import { CruiseError } from '../errors.js';
+export declare function buildFileGraph(baseDir: string, sourceRoots: readonly string[], ignoredPaths: readonly string[]): Effect.Effect<FileGraph, CruiseError>;
+//# sourceMappingURL=oxc.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"oxc.d.ts","sourceRoot":"","sources":["../../../../src/services/file-cruiser/oxc/oxc.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qCAAqC,CAAC;AACrE,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAQ3C,wBAAgB,cAAc,CAC5B,OAAO,EAAE,MAAM,EACf,WAAW,EAAE,SAAS,MAAM,EAAE,EAC9B,YAAY,EAAE,SAAS,MAAM,EAAE,GAC9B,MAAM,CAAC,MAAM,CAAC,SAAS,EAAE,WAAW,CAAC,CAoCvC"}

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

@@ -0,0 +1,29 @@
+import { realpath } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { Effect } from 'effect';
+import { CruiseError } from '../errors.js';
+import { listSourceFiles, pathContains } from './file-scanner.js';
+import { createResolver, extractSpecifiers, resolveSpecifier, } from './import-resolver.js';
+export function buildFileGraph(baseDir, sourceRoots, ignoredPaths) {
+    return Effect.tryPromise({
+        try: async () => {
+            const realBaseDir = await realpath(baseDir);
+            const files = await listSourceFiles(realBaseDir, sourceRoots);
+            const eligibleFiles = files.filter((path) => !ignoredPaths.some((ignored) => pathContains(ignored, path)));
+            const eligible = new Set(eligibleFiles);
+            const imports = new Map(eligibleFiles.map((path) => [path, new Set()]));
+            const resolver = createResolver();
+            for (const path of eligibleFiles) {
+                const absolute = resolve(realBaseDir, path);
+                const specifiers = await extractSpecifiers(absolute);
+                for (const specifier of specifiers) {
+                    const to = resolveSpecifier(resolver, realBaseDir, eligible, absolute, specifier);
+                    if (to !== undefined)
+                        imports.get(path).add(to);
+                }
+            }
+            return new Map(eligibleFiles.map((path) => [path, [...imports.get(path)].sort()]));
+        },
+        catch: (cause) => new CruiseError({ baseDir, cause }),
+    }).pipe(Effect.withSpan('dependencies.extract'));
+}

package/dist/services/git/changed-paths.d.ts

@@ -0,0 +1,4 @@
+import type { ChangeSet, DiffHunk } from '../../change-set-schema/index.js';
+export declare function readChangeSet(baseDir: string, baseRef: string): Promise<ChangeSet>;
+export declare function readFileDiff(baseDir: string, baseRef: string, path: string): Promise<readonly DiffHunk[]>;
+//# sourceMappingURL=changed-paths.d.ts.map

package/dist/services/git/changed-paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"changed-paths.d.ts","sourceRoot":"","sources":["../../../src/services/git/changed-paths.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,SAAS,EAET,QAAQ,EACT,MAAM,kCAAkC,CAAC;AAY1C,wBAAsB,aAAa,CACjC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,GACd,OAAO,CAAC,SAAS,CAAC,CA+BpB;AA8CD,wBAAsB,YAAY,CAChC,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,SAAS,QAAQ,EAAE,CAAC,CAiB9B"}