@doubleloop-io/oxlint-plugin-effect 0.0.0-stage → 0.1.0-rc.0

package/dist/rules/redacted-secret-names.js

@@ -0,0 +1,127 @@
+import { defineRule } from "@oxlint/plugins";
+import { calleeOf, memberOf } from "../shared/effect-ast.js";
+import { propertyName } from "../shared/tagged-values.js";
+// A naming heuristic: `_JSON` is here because a service account key travels as inline JSON.
+const secretName = /(KEY|SECRET|TOKEN|PASSWORD|CREDENTIALS?|_JSON)$/;
+// No generic `token`: `nextPageToken` and `tokenType` are not secrets.
+const defaultSecretFields = [
+    "password",
+    "secret",
+    "apiKey",
+    "accessToken",
+    "refreshToken",
+    "idToken",
+];
+const nullableWrappers = new Set(["optional", "optionalKey", "NullOr", "UndefinedOr", "NullishOr"]);
+const chainMethods = new Set(["pipe", "check", "annotate"]);
+const isRedactedSchema = (node) => node?.type === "CallExpression" &&
+    (memberOf(node.callee, "Schema")?.startsWith("Redacted") ?? false);
+const isRedactedConfig = (node) => {
+    const name = calleeOf(node, "Config");
+    return (name === "redacted" ||
+        (name === "schema" && isRedactedSchema(node.arguments[0])) ||
+        calleeOf(node.parent, "Config") === "redacted");
+};
+const isRedactedReference = (node) => (memberOf(node, "Schema") ?? calleeOf(node, "Schema"))?.startsWith("Redacted") ?? false;
+// `Schema.String`, `Schema.NonEmptyString.check(…)`, `Schema.optional(Schema.String)`: a schema
+// that is visibly plain text. A named schema (`AccessToken`) may already be `Redacted`.
+const isPlainSchema = (node) => {
+    if (node?.type === "MemberExpression") {
+        const name = memberOf(node, "Schema");
+        return name !== undefined && !name.startsWith("Redacted");
+    }
+    if (node?.type !== "CallExpression")
+        return false;
+    const wrapper = calleeOf(node, "Schema");
+    if (wrapper !== undefined)
+        return nullableWrappers.has(wrapper) && isPlainSchema(node.arguments[0]);
+    const { callee } = node;
+    if (callee.type !== "MemberExpression" ||
+        callee.computed ||
+        callee.property.type !== "Identifier" ||
+        !chainMethods.has(callee.property.name)) {
+        return false;
+    }
+    return !node.arguments.some(isRedactedReference) && isPlainSchema(callee.object);
+};
+// `Schema.Struct({…})` and `Schema.Class<X>("X")({…})`.
+const fieldsOf = (node) => {
+    const isStruct = calleeOf(node, "Schema") === "Struct";
+    const isClass = calleeOf(node.callee, "Schema") === "Class";
+    const fields = isStruct || isClass ? node.arguments[0] : undefined;
+    return fields?.type === "ObjectExpression" ? fields : undefined;
+};
+// `password` matches `password` and `dbPassword`, not `passwordPolicy`.
+const matchesSecretField = (name, secretFields) => secretFields.some((field) => name === field || name.endsWith(`${field.charAt(0).toUpperCase()}${field.slice(1)}`));
+const configuredSecretFields = (options) => {
+    const [first] = options;
+    if (typeof first !== "object" || first === null || !("secretFields" in first)) {
+        return defaultSecretFields;
+    }
+    const names = first.secretFields;
+    return Array.isArray(names) ? names.filter((name) => typeof name === "string") : [];
+};
+export const redactedSecretNamesRule = defineRule({
+    meta: {
+        type: "suggestion",
+        docs: {
+            description: "Read configuration values and declare Schema fields whose name looks like a secret as `Redacted`.",
+        },
+        messages: {
+            notRedacted: "`{{name}}` looks like a secret: read it with `Config.redacted` or `Config.schema(Schema.Redacted(...), name)`.",
+            fieldNotRedacted: "`{{name}}` looks like a secret: declare it as `Schema.Redacted(...)` so it stays out of logs.",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    secretFields: { type: "array", items: { type: "string" }, uniqueItems: true },
+                },
+                additionalProperties: false,
+            },
+        ],
+    },
+    createOnce(context) {
+        let secretFields = defaultSecretFields;
+        const checkConfig = (node) => {
+            if (calleeOf(node, "Config") === undefined || isRedactedConfig(node))
+                return;
+            for (const argument of node.arguments) {
+                if (argument.type === "Literal" &&
+                    typeof argument.value === "string" &&
+                    secretName.test(argument.value)) {
+                    context.report({
+                        node: argument,
+                        messageId: "notRedacted",
+                        data: { name: argument.value },
+                    });
+                }
+            }
+        };
+        const checkSchemaFields = (node) => {
+            for (const property of fieldsOf(node)?.properties ?? []) {
+                if (property.type !== "Property")
+                    continue;
+                const name = propertyName(property);
+                if (name === undefined || !matchesSecretField(name, secretFields))
+                    continue;
+                if (!isPlainSchema(property.value))
+                    continue;
+                context.report({
+                    node: property.key,
+                    messageId: "fieldNotRedacted",
+                    data: { name },
+                });
+            }
+        };
+        return {
+            before() {
+                secretFields = configuredSecretFields(context.options);
+            },
+            CallExpression(node) {
+                checkConfig(node);
+                checkSchemaFields(node);
+            },
+        };
+    },
+});

package/dist/rules/run-only-at-entry.d.ts

@@ -0,0 +1 @@
+export declare const runOnlyAtEntryRule: import("@oxlint/plugins").Rule;

package/dist/rules/run-only-at-entry.js

@@ -0,0 +1,50 @@
+import { defineRule } from "@oxlint/plugins";
+import { memberOf } from "../shared/effect-ast.js";
+import { isEntryFile } from "../shared/entry-files.js";
+import { filePatternsSchema } from "../shared/file-globs.js";
+const runtimeEntries = [
+    ["NodeRuntime", "runMain"],
+    ["BunRuntime", "runMain"],
+    ["ManagedRuntime", "make"],
+];
+const runnerName = (node) => {
+    const effectMember = memberOf(node, "Effect");
+    if (effectMember?.startsWith("run"))
+        return `Effect.${effectMember}`;
+    const entry = runtimeEntries.find(([object, property]) => memberOf(node, object) === property);
+    return entry === undefined ? undefined : `${entry[0]}.${entry[1]}`;
+};
+// Reports references too, not only calls: `const run = Effect.runPromise` escapes nothing.
+export const runOnlyAtEntryRule = defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Run Effect programs only at the entry point. Entry files are skipped.",
+        },
+        messages: {
+            runOutsideEntry: "`{{name}}` runs an Effect program: only the entry point may do that. Tests use `it.effect`, or a single test runner listed in `entryFiles`.",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: { entryFiles: filePatternsSchema },
+                additionalProperties: false,
+            },
+        ],
+    },
+    createOnce(context) {
+        let inEntryFile = false;
+        return {
+            before() {
+                inEntryFile = isEntryFile(context);
+            },
+            MemberExpression(node) {
+                if (inEntryFile)
+                    return;
+                const name = runnerName(node);
+                if (name !== undefined)
+                    context.report({ node, messageId: "runOutsideEntry", data: { name } });
+            },
+        };
+    },
+});

package/dist/rules/service-built-with-of.d.ts

@@ -0,0 +1 @@
+export declare const serviceBuiltWithOfRule: import("@oxlint/plugins").Rule;

package/dist/rules/service-built-with-of.js

@@ -0,0 +1,74 @@
+import { defineRule } from "@oxlint/plugins";
+import { calleeOf, isFunctionNode } from "../shared/effect-ast.js";
+const layerConstructors = new Set(["succeed", "sync", "effect", "scoped"]);
+// `Layer.succeed(T, impl)` and the curried `Layer.succeed(T)(impl)`.
+const layerApplication = (node) => {
+    const dataFirst = calleeOf(node, "Layer");
+    if (dataFirst !== undefined && node.arguments.length === 2) {
+        return { constructor: dataFirst, tag: node.arguments[0], impl: node.arguments[1] };
+    }
+    const curried = node.callee.type === "CallExpression" ? calleeOf(node.callee, "Layer") : undefined;
+    if (curried !== undefined && node.callee.type === "CallExpression") {
+        return { constructor: curried, tag: node.callee.arguments[0], impl: node.arguments[0] };
+    }
+    return undefined;
+};
+const returnedObjects = (fn) => {
+    if (fn.body?.type === "ObjectExpression")
+        return [fn.body];
+    if (fn.body?.type !== "BlockStatement")
+        return [];
+    return fn.body.body.flatMap((statement) => statement.type === "ReturnStatement" && statement.argument?.type === "ObjectExpression"
+        ? [statement.argument]
+        : []);
+};
+const implementationObjects = (constructor, impl) => {
+    if (constructor === "succeed")
+        return impl?.type === "ObjectExpression" ? [impl] : [];
+    if (constructor === "sync")
+        return isFunctionNode(impl) ? returnedObjects(impl) : [];
+    if (impl?.type !== "CallExpression" || calleeOf(impl, "Effect") !== "gen")
+        return [];
+    return impl.arguments.flatMap((argument) => isFunctionNode(argument) && argument.generator ? returnedObjects(argument) : []);
+};
+export const serviceBuiltWithOfRule = defineRule({
+    meta: {
+        type: "suggestion",
+        docs: {
+            description: "Build the service a Layer provides with `Tag.of({…})` instead of a bare object literal.",
+        },
+        hasSuggestions: true,
+        messages: {
+            bareLiteral: "Build the service with `{{tag}}.of({…})`: it names the service the object implements and keeps its type checked if the literal moves out of the Layer.",
+            wrapWithOf: "Wrap the literal in `{{tag}}.of(…)`.",
+        },
+    },
+    createOnce(context) {
+        return {
+            CallExpression(node) {
+                const application = layerApplication(node);
+                if (application === undefined || !layerConstructors.has(application.constructor)) {
+                    return;
+                }
+                const { tag, impl } = application;
+                if (tag === undefined || tag.type === "SpreadElement")
+                    return;
+                const tagText = context.sourceCode.getText(tag);
+                for (const literal of implementationObjects(application.constructor, impl)) {
+                    context.report({
+                        node: literal,
+                        messageId: "bareLiteral",
+                        data: { tag: tagText },
+                        suggest: [
+                            {
+                                messageId: "wrapWithOf",
+                                data: { tag: tagText },
+                                fix: (fixer) => fixer.replaceText(literal, `${tagText}.of(${context.sourceCode.getText(literal)})`),
+                            },
+                        ],
+                    });
+                }
+            },
+        };
+    },
+});

package/dist/rules/service-key-matches-name.d.ts

@@ -0,0 +1 @@
+export declare const serviceKeyMatchesNameRule: import("@oxlint/plugins").Rule;

package/dist/rules/service-key-matches-name.js

@@ -0,0 +1,69 @@
+import { defineRule } from "@oxlint/plugins";
+import { calleeOf } from "../shared/effect-ast.js";
+// `class X extends Context.Service<X, Shape>()(key)`: the outer call carries the key.
+const contextServiceKey = (superClass) => superClass?.type === "CallExpression" && calleeOf(superClass.callee, "Context") === "Service"
+    ? superClass.arguments[0]
+    : undefined;
+const literalKey = (node) => {
+    if (node?.type === "Literal" && typeof node.value === "string")
+        return node.value;
+    if (node?.type === "TemplateLiteral" && node.expressions.length === 0) {
+        return node.quasis[0]?.value.cooked ?? undefined;
+    }
+    return undefined;
+};
+const className = (node) => {
+    if (node.id !== null)
+        return node.id.name;
+    const declarator = node.parent;
+    return declarator?.type === "VariableDeclarator" && declarator.id.type === "Identifier"
+        ? declarator.id.name
+        : undefined;
+};
+// A path prefix (`"app/db/Database"`) is the key `AGENTS.md` recommends: only the last segment
+// has to be the name.
+const keyFor = (key, name) => {
+    const slash = key.lastIndexOf("/");
+    return slash === -1 ? name : `${key.slice(0, slash + 1)}${name}`;
+};
+export const serviceKeyMatchesNameRule = defineRule({
+    meta: {
+        type: "suggestion",
+        docs: {
+            description: "Key a `Context.Service` class with its own name, alone or after a path prefix.",
+        },
+        hasSuggestions: true,
+        messages: {
+            keyMismatch: 'The key `"{{key}}"` does not end with the class name `{{name}}`: the key is the service\'s identity in errors and traces.',
+            useKey: 'Use `"{{expected}}"`.',
+        },
+    },
+    createOnce(context) {
+        const checkClass = (node) => {
+            const keyNode = contextServiceKey(node.superClass);
+            const key = literalKey(keyNode);
+            const name = className(node);
+            if (keyNode === undefined || key === undefined || name === undefined)
+                return;
+            if (key === name || key.endsWith(`/${name}`))
+                return;
+            const expected = keyFor(key, name);
+            context.report({
+                node: keyNode,
+                messageId: "keyMismatch",
+                data: { key, name },
+                suggest: [
+                    {
+                        messageId: "useKey",
+                        data: { expected },
+                        fix: (fixer) => fixer.replaceText(keyNode, JSON.stringify(expected)),
+                    },
+                ],
+            });
+        };
+        return {
+            ClassDeclaration: checkClass,
+            ClassExpression: checkClass,
+        };
+    },
+});

package/dist/rules/service-port-shape-only.d.ts

@@ -0,0 +1 @@
+export declare const servicePortShapeOnlyRule: import("@oxlint/plugins").Rule;

package/dist/rules/service-port-shape-only.js

@@ -0,0 +1,65 @@
+import { defineRule } from "@oxlint/plugins";
+import { calleeOf, memberOf } from "../shared/effect-ast.js";
+const legacyServices = [
+    ["Effect", "Service"],
+    ["Context", "Tag"],
+    ["Context", "GenericTag"],
+];
+const implementationStatics = new Set(["layer", "Default"]);
+// `class X extends Context.Service<X, Shape>()(id, options?)`: the outer call carries the id.
+const contextServiceIdCall = (superClass) => superClass?.type === "CallExpression" && calleeOf(superClass.callee, "Context") === "Service"
+    ? superClass
+    : undefined;
+const staticMemberName = (member) => (member.type === "PropertyDefinition" || member.type === "MethodDefinition") &&
+    member.static &&
+    member.key.type === "Identifier"
+    ? member.key.name
+    : undefined;
+export const servicePortShapeOnlyRule = defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Keep a `Context.Service` port a pure contract, with implementations in separate Layers.",
+        },
+        messages: {
+            makeOption: "Declare the port as shape only: move the implementation into a Layer in its own adapter file.",
+            staticImplementation: "Do not attach `static {{name}}` to the port: provide the implementation as a Layer in its own adapter file.",
+            legacyService: "Use `class X extends Context.Service<X, Shape>()(id) {}` instead of `{{name}}`.",
+        },
+    },
+    createOnce(context) {
+        const checkClass = (node) => {
+            const idCall = contextServiceIdCall(node.superClass);
+            if (idCall === undefined)
+                return;
+            const options = idCall.arguments[1];
+            if (options !== undefined)
+                context.report({ node: options, messageId: "makeOption" });
+            for (const member of node.body.body) {
+                const name = staticMemberName(member);
+                if (name !== undefined && implementationStatics.has(name)) {
+                    context.report({
+                        node: member,
+                        messageId: "staticImplementation",
+                        data: { name },
+                    });
+                }
+            }
+        };
+        return {
+            ClassDeclaration: checkClass,
+            ClassExpression: checkClass,
+            MemberExpression(node) {
+                for (const [object, property] of legacyServices) {
+                    if (memberOf(node, object) === property) {
+                        context.report({
+                            node,
+                            messageId: "legacyService",
+                            data: { name: `${object}.${property}` },
+                        });
+                    }
+                }
+            },
+        };
+    },
+});

package/dist/rules/single-style-per-function.d.ts

@@ -0,0 +1 @@
+export declare const singleStylePerFunctionRule: import("@oxlint/plugins").Rule;

package/dist/rules/single-style-per-function.js

@@ -0,0 +1,77 @@
+import { defineRule } from "@oxlint/plugins";
+import { isEffectGenerator, memberOf } from "../shared/effect-ast.js";
+const isThenCall = (node) => node.callee.type === "MemberExpression" &&
+    !node.callee.computed &&
+    node.callee.property.type === "Identifier" &&
+    node.callee.property.name === "then";
+const testRunners = new Set(["test", "it"]);
+// `test(…)`, `test.only(…)`, `test.each(table)(…)`: the callee chain roots at `test` or `it`.
+const isTestCallback = (fn) => {
+    const call = fn.parent;
+    if (call?.type !== "CallExpression" || !call.arguments.some((arg) => arg === fn))
+        return false;
+    let callee = call.callee;
+    while (callee.type === "MemberExpression" || callee.type === "CallExpression") {
+        callee = callee.type === "MemberExpression" ? callee.object : callee.callee;
+    }
+    return callee.type === "Identifier" && testRunners.has(callee.name);
+};
+export const singleStylePerFunctionRule = defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Keep each function entirely Effect or entirely async/await.",
+        },
+        messages: {
+            asyncEffect: "This function builds Effects: drop `async` and lift promises with `Effect.tryPromise({ try, catch })`.",
+            promiseStep: "Do not mix promises with Effect in the same function: lift the promise with `Effect.tryPromise({ try, catch })`.",
+            asyncEffectTest: "This test mixes promises with Effect: make its body one Effect, with `it.effect` from `@effect/vitest` or by returning a single test runner call from a non-async callback.",
+        },
+    },
+    createOnce(context) {
+        const frames = [];
+        const current = () => frames.at(-1);
+        const enter = (fn) => {
+            frames.push({ fn, effectful: isEffectGenerator(fn), promiseSteps: [] });
+        };
+        const exit = () => {
+            const frame = frames.pop();
+            if (frame === undefined || !frame.effectful)
+                return;
+            // One report per test: the remedy is the test's shape, not each promise in it.
+            if (isTestCallback(frame.fn)) {
+                if (frame.fn.async || frame.promiseSteps.length > 0)
+                    context.report({ node: frame.fn, messageId: "asyncEffectTest" });
+                return;
+            }
+            if (frame.fn.async)
+                context.report({ node: frame.fn, messageId: "asyncEffect" });
+            for (const node of frame.promiseSteps)
+                context.report({ node, messageId: "promiseStep" });
+        };
+        return {
+            ArrowFunctionExpression: enter,
+            FunctionExpression: enter,
+            FunctionDeclaration: enter,
+            "ArrowFunctionExpression:exit": exit,
+            "FunctionExpression:exit": exit,
+            "FunctionDeclaration:exit": exit,
+            MemberExpression(node) {
+                const frame = current();
+                const name = memberOf(node, "Effect");
+                // `Effect.run*` is how an async boundary legitimately hands off to Effect (P27);
+                // where it may appear is run-only-at-entry's business.
+                if (frame !== undefined && name !== undefined && !name.startsWith("run")) {
+                    frame.effectful = true;
+                }
+            },
+            AwaitExpression(node) {
+                current()?.promiseSteps.push(node);
+            },
+            CallExpression(node) {
+                if (isThenCall(node))
+                    current()?.promiseSteps.push(node);
+            },
+        };
+    },
+});

package/dist/rules/try-object-form.d.ts

@@ -0,0 +1 @@
+export declare const tryObjectFormRule: import("@oxlint/plugins").Rule;

package/dist/rules/try-object-form.js

@@ -0,0 +1,26 @@
+import { defineRule } from "@oxlint/plugins";
+import { calleeOf } from "../shared/effect-ast.js";
+const tryConstructors = new Set(["try", "tryPromise"]);
+export const tryObjectFormRule = defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Use the object form of `Effect.try` and `Effect.tryPromise`, mapping failures to tagged errors.",
+        },
+        messages: {
+            objectForm: "Use `Effect.{{name}}({ try, catch })`: the thunk form types the failure as `Cause.UnknownError`.",
+        },
+    },
+    createOnce(context) {
+        return {
+            CallExpression(node) {
+                const name = calleeOf(node, "Effect");
+                if (name === undefined || !tryConstructors.has(name))
+                    return;
+                if (node.arguments[0]?.type !== "ObjectExpression") {
+                    context.report({ node, messageId: "objectForm", data: { name } });
+                }
+            },
+        };
+    },
+});

package/dist/rules/untraced-recursion.d.ts

@@ -0,0 +1 @@
+export declare const untracedRecursionRule: import("@oxlint/plugins").Rule;

package/dist/rules/untraced-recursion.js

@@ -0,0 +1,48 @@
+import { defineRule } from "@oxlint/plugins";
+import { calleeOf, isFunctionNode } from "../shared/effect-ast.js";
+// `Effect.fn("name")(body)` and `Effect.fn(body)`; `Effect.fnUntraced` is what the rule asks for.
+const tracedBody = (node) => {
+    if (node?.type !== "CallExpression")
+        return undefined;
+    const isTraced = calleeOf(node, "Effect") === "fn" || calleeOf(node.callee, "Effect") === "fn";
+    const [body] = node.arguments;
+    return isTraced && isFunctionNode(body) ? body : undefined;
+};
+const isInside = (node, ancestor) => {
+    for (let current = node.parent; current; current = current.parent) {
+        if (current === ancestor)
+            return true;
+    }
+    return false;
+};
+// Every recursive call of a traced function opens a span nested in the previous one and
+// captures a stack frame: the trace grows with the depth instead of naming one unit of work.
+export const untracedRecursionRule = defineRule({
+    meta: {
+        type: "suggestion",
+        docs: {
+            description: "Write recursive effectful functions with `Effect.fnUntraced`, so each level does not open a nested span.",
+        },
+        messages: {
+            recursiveTraced: "`{{name}}` calls itself: use `Effect.fnUntraced` and trace the entry point that starts the recursion.",
+        },
+    },
+    createOnce(context) {
+        return {
+            VariableDeclarator(node) {
+                const body = tracedBody(node.init);
+                if (node.id.type !== "Identifier" || body === undefined)
+                    return;
+                const [variable] = context.sourceCode.getDeclaredVariables(node);
+                const recursive = variable?.references.some((reference) => isInside(reference.identifier, body));
+                if (recursive === true) {
+                    context.report({
+                        node: node.id,
+                        messageId: "recursiveTraced",
+                        data: { name: node.id.name },
+                    });
+                }
+            },
+        };
+    },
+});

package/dist/shared/effect-ast.d.ts

@@ -0,0 +1,9 @@
+import type { ESTree } from "@oxlint/plugins";
+export type FunctionNode = ESTree.Function | ESTree.ArrowFunctionExpression;
+export declare const isFunctionNode: (node: ESTree.Node | null | undefined) => node is FunctionNode;
+export declare const memberOf: (node: ESTree.Node | null | undefined, object: string) => string | undefined;
+export declare const calleeOf: (node: ESTree.Node | null | undefined, object: string) => string | undefined;
+export declare const isEffectFnApplication: (node: ESTree.Node | null | undefined) => node is ESTree.CallExpression;
+export declare const isEffectGenerator: (fn: FunctionNode) => boolean;
+export declare const isInsideEffectGeneratorBody: (node: ESTree.Node) => boolean;
+export declare const nearestFunction: (node: ESTree.Node) => FunctionNode | undefined;

package/dist/shared/effect-ast.js

@@ -0,0 +1,52 @@
+export const isFunctionNode = (node) => node?.type === "ArrowFunctionExpression" ||
+    node?.type === "FunctionExpression" ||
+    node?.type === "FunctionDeclaration";
+// Like the anti-slop rules, names are matched literally: `import { Effect as E }` escapes.
+export const memberOf = (node, object) => {
+    if (node?.type !== "MemberExpression" ||
+        node.computed ||
+        node.object.type !== "Identifier" ||
+        node.object.name !== object ||
+        node.property.type !== "Identifier") {
+        return undefined;
+    }
+    return node.property.name;
+};
+export const calleeOf = (node, object) => node?.type === "CallExpression" ? memberOf(node.callee, object) : undefined;
+// Both `Effect.fn("name")(body, ...pipeables)` and the unnamed `Effect.fn(body, ...pipeables)`.
+export const isEffectFnApplication = (node) => {
+    if (node?.type !== "CallExpression")
+        return false;
+    const factory = memberOf(node.callee, "Effect");
+    return factory === "fn" || factory === "fnUntraced" || calleeOf(node.callee, "Effect") === "fn";
+};
+export const isEffectGenerator = (fn) => {
+    const call = fn.parent;
+    if (!fn.generator || call?.type !== "CallExpression")
+        return false;
+    if (calleeOf(call, "Effect") === "gen")
+        return call.arguments.some((arg) => arg === fn);
+    return isEffectFnApplication(call) && call.arguments[0] === fn;
+};
+// Plain callbacks inside the generator still belong to its success path; the pipeable
+// arguments of an `Effect.fn` nested in it are the handler slot, so they do not.
+export const isInsideEffectGeneratorBody = (node) => {
+    let child = node;
+    for (let current = node.parent; current; current = current.parent) {
+        if (isEffectFnApplication(current) &&
+            current.arguments.findIndex((arg) => arg === child) > 0) {
+            return false;
+        }
+        if (isFunctionNode(current) && current.generator)
+            return isEffectGenerator(current);
+        child = current;
+    }
+    return false;
+};
+export const nearestFunction = (node) => {
+    for (let current = node.parent; current; current = current.parent) {
+        if (isFunctionNode(current))
+            return current;
+    }
+    return undefined;
+};

package/dist/shared/entry-files.d.ts

@@ -0,0 +1,6 @@
+export declare const defaultEntryFiles: string[];
+export declare const isEntryFile: (context: {
+    readonly filename: string;
+    readonly cwd: string;
+    readonly options: ReadonlyArray<unknown>;
+}) => boolean;

package/dist/shared/entry-files.js

@@ -0,0 +1,5 @@
+import { makeFileMatcher } from "./file-globs.js";
+// `index.ts` is not matched on purpose: it is usually a barrel, and exempting it would let
+// adapters reach the rest of the application through the re-exports.
+export const defaultEntryFiles = ["**/main.ts", "**/cli.ts", "**/bin/**"];
+export const isEntryFile = makeFileMatcher("entryFiles", defaultEntryFiles);

package/dist/shared/file-globs.d.ts

@@ -0,0 +1,14 @@
+export declare const filePatternsSchema: {
+    type: string;
+    items: {
+        type: string;
+    };
+    uniqueItems: boolean;
+};
+type FileContext = {
+    readonly filename: string;
+    readonly cwd: string;
+    readonly options: ReadonlyArray<unknown>;
+};
+export declare const makeFileMatcher: (key: string, defaults: ReadonlyArray<string>) => (context: FileContext) => boolean;
+export {};