@foldkit/oxlint-plugin 0.10.0 → 0.11.0-canary.0053b7691fcd

package/dist/index.js

@@ -4,7 +4,7 @@ var __export = (target, all5) => {
     __defProp(target, name, { get: all5[name], enumerable: true });
 };
 
-// ../../node_modules/.pnpm/effect-oxlint@0.3.2_effect@4.0.0-rc.112/node_modules/effect-oxlint/dist/chunk.js
+// ../../node_modules/.pnpm/effect-oxlint@0.3.4_effect@4.0.0-rc.112/node_modules/effect-oxlint/dist/rolldown-runtime.js
 var __defProp2 = Object.defineProperty;
 var __exportAll = (all5, no_symbols) => {
   let target = {};
@@ -7399,7 +7399,7 @@ var flatMapEager2 = flatMapEager;
 var catchEager2 = catchEager;
 var fnUntracedEager2 = fnUntracedEager;
 
-// ../../node_modules/.pnpm/effect-oxlint@0.3.2_effect@4.0.0-rc.112/node_modules/effect-oxlint/dist/RuleContext.js
+// ../../node_modules/.pnpm/effect-oxlint@0.3.4_effect@4.0.0-rc.112/node_modules/effect-oxlint/dist/RuleContext.js
 var RuleContextBase = Service()("effect-oxlint/RuleContext");
 var RuleContext = class extends RuleContextBase {
 };
@@ -8300,7 +8300,7 @@ var Objects = class _Objects extends Base2 {
     if (!hasProperties && !indexCount) {
       return fromRefinement(ast, isNotNullish);
     }
-    let properties;
+    let properties2;
     let indexes;
     const finishIndex = (s, key, k2, inputValue, exitValue) => {
       if (exitValue._tag === "Failure") {
@@ -8339,8 +8339,8 @@ var Objects = class _Objects extends Base2 {
       step: (_s, _, exit3) => exit3._tag === "Failure" ? exit3 : void 0
     }) : void 0;
     const compileMembers = () => {
-      if (!properties) {
-        properties = ast.propertySignatures.map((ps) => ({
+      if (!properties2) {
+        properties2 = ast.propertySignatures.map((ps) => ({
           parser: compileConstructorDefault2(ps.type),
           name: ps.name,
           type: ps.type
@@ -8351,7 +8351,7 @@ var Objects = class _Objects extends Base2 {
           parserValue: compileConstructorDefault2(is2.type)
         })) : void 0;
       }
-      return properties;
+      return properties2;
     };
     const fallback = fnUntracedEager2(function* (input, options) {
       if (input === missing) {
@@ -8401,7 +8401,7 @@ var Objects = class _Objects extends Base2 {
       }
       const concurrency = resolveConcurrency(options?.concurrency);
       if (hasProperties) {
-        const eff = parseProperties(state, properties, concurrency);
+        const eff = parseProperties(state, properties2, concurrency);
         if (eff) yield* eff;
       }
       if (indexCount && !concurrency) {
@@ -8444,12 +8444,12 @@ var Objects = class _Objects extends Base2 {
     });
     if (indexCount) return fallback;
     const resume = (state, index, pending) => {
-      const property = properties[index];
+      const property = properties2[index];
       return flatMap5(exit2(pending), (exit3) => {
         const terminal = stepProperty(state, property, exit3);
         if (terminal) return terminal;
         const done4 = () => succeed6(state.out);
-        const eff = parseProperties(state, properties.slice(index + 1));
+        const eff = parseProperties(state, properties2.slice(index + 1));
         return eff ? flatMapEager2(eff, done4) : done4();
       });
     };
@@ -9594,6 +9594,7 @@ function decodeUnknownSync(schema, options) {
     return runSchemaErrorSync(parser(input, options2));
   };
 }
+var decodeSync2 = decodeUnknownSync;
 var make13 = make12;
 function Literal2(literal) {
   const out = make13(new Literal(literal), {
@@ -10014,7 +10015,7 @@ var updateSomeAndGet = /* @__PURE__ */ dual(2, (self, pf) => sync2(() => {
 }));
 var getUnsafe3 = (self) => self.ref.current;
 
-// ../../node_modules/.pnpm/effect-oxlint@0.3.2_effect@4.0.0-rc.112/node_modules/effect-oxlint/dist/index.js
+// ../../node_modules/.pnpm/effect-oxlint@0.3.4_effect@4.0.0-rc.112/node_modules/effect-oxlint/dist/index.js
 var AST_exports = /* @__PURE__ */ __exportAll({
   calleeIdentifier: () => calleeIdentifier,
   calleeName: () => calleeName,
@@ -10218,10 +10219,11 @@ var define = (config) => ({
     const decodeOptions = () => {
       const schema = config.options;
       if (schema === void 0) return void 0;
-      return decodeUnknownSync(schema)(oxlintContext.options[0]);
+      return decodeSync2(schema)(oxlintContext.options[0]);
     };
     const options = run2(sync2(decodeOptions));
-    return toOxlintVisitor(run2(gen4(() => config.create(options))), run2);
+    const effectVisitor = run2(gen4(() => config.create(options)));
+    return toOxlintVisitor(effectVisitor, run2);
   }
 });
 var meta = (opts) => ({
@@ -10385,11 +10387,13 @@ var isPunctuator = dual(2, (token, value) => token.type === "Punctuator" && toke
 
 // src/guards.ts
 var isIdentifier = (node, name) => typeof node === "object" && node !== null && "type" in node && node.type === "Identifier" && "name" in node && typeof node.name === "string" && (name === void 0 || node.name === name);
+var isIdentifierReference = (node) => isIdentifier(node);
 var isStringLiteral = (node) => typeof node === "object" && node !== null && "type" in node && node.type === "Literal" && "value" in node && typeof node.value === "string";
 var isTemplateLiteral = (node) => typeof node === "object" && node !== null && "type" in node && node.type === "TemplateLiteral";
 var isCallExpression = (node) => typeof node === "object" && node !== null && "type" in node && node.type === "CallExpression";
 var isMemberExpression = (node) => typeof node === "object" && node !== null && "type" in node && node.type === "MemberExpression";
 var isObjectExpression = (node) => typeof node === "object" && node !== null && "type" in node && node.type === "ObjectExpression";
+var isObjectProperty = (node) => typeof node === "object" && node !== null && "type" in node && node.type === "Property";
 var isArrayExpression = (node) => typeof node === "object" && node !== null && "type" in node && node.type === "ArrayExpression";
 var isSpreadElement = (node) => typeof node === "object" && node !== null && "type" in node && node.type === "SpreadElement";
 var helperCalleeName = (callee) => {
@@ -10414,6 +10418,34 @@ var staticStringValue = (node) => {
   }
   return Option_exports.none();
 };
+var staticMemberName = (node) => {
+  if (!node.computed && isIdentifier(node.property)) {
+    return Option_exports.some(node.property.name);
+  }
+  return staticStringValue(node.property);
+};
+var staticPropertyName = (property) => {
+  if (!property.computed && isIdentifier(property.key)) {
+    return Option_exports.some(property.key.name);
+  }
+  return staticStringValue(property.key);
+};
+var indexReferences = (scopes) => {
+  const references = /* @__PURE__ */ new WeakMap();
+  for (const scope3 of scopes) {
+    for (const reference of scope3.references) {
+      references.set(reference.identifier, reference);
+    }
+  }
+  return references;
+};
+var isUnshadowedReference = (references, node) => {
+  if (references === void 0) {
+    return true;
+  }
+  const reference = references.get(node);
+  return reference !== void 0 && (reference.resolved === null || Array_exports.isArrayEmpty(reference.resolved.defs));
+};
 var isVariableDeclarator = (node) => typeof node === "object" && node !== null && "type" in node && node.type === "VariableDeclarator";
 var isVariableDeclaration = (node) => typeof node === "object" && node !== null && "type" in node && node.type === "VariableDeclaration";
 var isProgram = (node) => typeof node === "object" && node !== null && "type" in node && node.type === "Program";
@@ -10542,18 +10574,6 @@ var commandDefinePascalConst = Rule_exports.define({
 
 // src/message.ts
 var foldkitMessageModule = "foldkit/message";
-var staticPropertyName = (property) => {
-  if (property.type !== "Property") {
-    return Option_exports.none();
-  }
-  if (!property.computed && isIdentifier(property.key)) {
-    return Option_exports.some({ name: property.key.name, node: property.key });
-  }
-  if (isStringLiteral(property.key)) {
-    return Option_exports.some({ name: property.key.value, node: property.key });
-  }
-  return Option_exports.none();
-};
 var recordFoldkitMessageUnionBindings = (bindings, node) => {
   if (node.type !== "Program") {
     return;
@@ -10578,14 +10598,17 @@ var messageCases = (node, bindings) => {
     return [];
   }
   return casesByTag.properties.flatMap((property) => {
+    if (property.type !== "Property") {
+      return [];
+    }
     const maybeName = staticPropertyName(property);
-    if (property.type !== "Property" || Option_exports.isNone(maybeName) || !isObjectExpression(property.value)) {
+    if (Option_exports.isNone(maybeName) || !isObjectExpression(property.value)) {
       return [];
     }
     return [
       {
-        name: maybeName.value.name,
-        nameNode: maybeName.value.node,
+        name: maybeName.value,
+        nameNode: property.key,
         fields: property.value
       }
     ];
@@ -11086,92 +11109,134 @@ var lazyViewStableReferences = Rule_exports.define({
 
 // src/rules/mount-factory-must-use-element.ts
 var MOUNT_DEFINITION_METHODS = ["define", "defineStream"];
-var NO_ELEMENT_PARAMETER_MESSAGE = "This Mount factory never receives the element: it declares no usable element parameter. A Mount exists for element-caused, element-targeted work. If the element is irrelevant, use a Command, Subscription, or ManagedResource instead.";
-var ignoredElementParameterMessage = (parameterName) => `The element parameter \`${parameterName}\` is named as ignored. A Mount factory must read or write its live element; if the element does not matter here, the side effect has a different cause and belongs in a Command, Subscription, or ManagedResource.`;
-var unusedElementParameterMessage = (parameterName) => `The element parameter \`${parameterName}\` is never referenced in this Mount factory. A Mount factory must use its live element; work that does not need the element belongs in a Command, Subscription, or ManagedResource.`;
-var isFactoryFunction = (node) => node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression";
-var isMountDefinitionChain = (call) => {
-  if (call.callee.type === "MemberExpression") {
-    return AST_exports.isMember(call.callee, "Mount", MOUNT_DEFINITION_METHODS);
-  }
-  if (call.callee.type === "CallExpression") {
-    return isMountDefinitionChain(call.callee);
-  }
-  return false;
-};
-var returnedFactoryFunction = (statement) => {
-  if (statement.type !== "ReturnStatement" || statement.argument === null) {
-    return Option_exports.none();
-  }
-  return isFactoryFunction(statement.argument) ? Option_exports.some(statement.argument) : Option_exports.none();
-};
-var descendToElementFactory = (builder) => {
-  const body = builder.body;
-  if (body === null) return builder;
-  if (isFactoryFunction(body)) return body;
-  if (body.type === "BlockStatement") {
-    return pipe(
-      body.body,
-      Array_exports.findFirst(returnedFactoryFunction),
-      Option_exports.getOrElse(() => builder)
-    );
-  }
-  return builder;
-};
+var ELEMENT_FIELD = "element";
+var NO_ELEMENT_BINDING_MESSAGE = `This Mount's \`execute\` never receives the element: it does not destructure \`element\` from its input. A Mount exists for element-caused, element-targeted work. If the element is irrelevant, use a Command, Subscription, or ManagedResource instead.`;
+var ignoredElementBindingMessage = (bindingName) => `The element binding \`${bindingName}\` is named as ignored. A Mount's \`execute\` must read or write its live element; if the element does not matter here, the side effect has a different cause and belongs in a Command, Subscription, or ManagedResource.`;
+var unusedElementBindingMessage = (bindingName) => `The element binding \`${bindingName}\` is never referenced in this Mount's \`execute\`. A Mount's \`execute\` must use its live element; work that does not need the element belongs in a Command, Subscription, or ManagedResource.`;
+var unreadElementFieldMessage = (bindingName) => `This Mount's \`execute\` reads other fields off \`${bindingName}\` but never its \`element\`. Destructure \`element\` from the input so the check can see the read, or if the element is irrelevant, use a Command, Subscription, or ManagedResource instead.`;
+var unusedInputMessage = (bindingName) => `This Mount's \`execute\` never references \`${bindingName}\`, so it never reaches the live element. Destructure \`element\` from the input so the check can see the read, or if the element is irrelevant, use a Command, Subscription, or ManagedResource instead.`;
+var isExecuteFunction = (node) => node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression";
 var isRecord = (value) => typeof value === "object" && value !== null;
-var shadowsParameterName = (functionNode, parameterName) => {
+var shadowsBindingName = (functionNode, bindingName) => {
   const parameters = functionNode.params;
   if (!isRecord(parameters)) return false;
   return Object.values(parameters).some(
-    (parameter) => isRecord(parameter) && parameter.type === "Identifier" && parameter.name === parameterName
+    (parameter) => isRecord(parameter) && parameter.type === "Identifier" && parameter.name === bindingName
   );
 };
-var referencesName = (value, parameterName) => {
+var referencesName = (value, bindingName) => {
   if (!isRecord(value)) return false;
-  if (value.type === "Identifier" && value.name === parameterName) return true;
-  if ((value.type === "ArrowFunctionExpression" || value.type === "FunctionExpression") && shadowsParameterName(value, parameterName)) {
+  if (value.type === "Identifier" && value.name === bindingName) return true;
+  if ((value.type === "ArrowFunctionExpression" || value.type === "FunctionExpression") && shadowsBindingName(value, bindingName)) {
     return false;
   }
+  if (value.type === "MemberExpression" && value.computed !== true) {
+    return referencesName(value.object, bindingName);
+  }
   if (value.type === "Property") {
-    const computedKeyReferences = value.computed === true && referencesName(value.key, parameterName);
-    return computedKeyReferences || referencesName(value.value, parameterName);
+    const computedKeyReferences = value.computed === true && referencesName(value.key, bindingName);
+    return computedKeyReferences || referencesName(value.value, bindingName);
   }
   return Object.entries(value).some(
-    ([key, child]) => key !== "parent" && referencesName(child, parameterName)
+    ([key, child]) => key !== "parent" && referencesName(child, bindingName)
   );
 };
-var elementFactoryDiagnostic = (factory) => {
-  const [firstParameter] = factory.params;
-  if (firstParameter === void 0 || firstParameter.type !== "Identifier") {
-    return Option_exports.some(NO_ELEMENT_PARAMETER_MESSAGE);
+var inputUses = (value, inputName) => {
+  if (!isRecord(value)) return [];
+  if (value.type === "MemberExpression" && isRecord(value.object) && value.object.type === "Identifier" && value.object.name === inputName) {
+    if (value.computed === true) return ["MaybeElement"];
+    return isRecord(value.property) && value.property.type === "Identifier" && value.property.name === ELEMENT_FIELD ? ["Element"] : ["OtherField"];
+  }
+  if (value.type === "MemberExpression" && value.computed !== true) {
+    return inputUses(value.object, inputName);
+  }
+  if ((value.type === "ArrowFunctionExpression" || value.type === "FunctionExpression") && shadowsBindingName(value, inputName)) {
+    return [];
+  }
+  if (value.type === "Property") {
+    const keyUses = value.computed === true ? inputUses(value.key, inputName) : [];
+    return [...keyUses, ...inputUses(value.value, inputName)];
   }
-  if (firstParameter.name.startsWith("_")) {
-    return Option_exports.some(ignoredElementParameterMessage(firstParameter.name));
+  if (value.type === "Identifier" && value.name === inputName) {
+    return ["MaybeElement"];
   }
-  return referencesName(factory.body, firstParameter.name) ? Option_exports.none() : Option_exports.some(unusedElementParameterMessage(firstParameter.name));
+  return Object.entries(value).flatMap(
+    ([key, child]) => key === "parent" ? [] : inputUses(child, inputName)
+  );
 };
+var elementProperty = (pattern) => pipe(
+  pattern.properties,
+  Array_exports.findFirst(
+    (property) => property.type === "Property" && (property.key.type === "Literal" ? property.key.value === ELEMENT_FIELD : !property.computed && property.key.type === "Identifier" && property.key.name === ELEMENT_FIELD)
+  )
+);
+var restBindingName = (pattern) => pipe(
+  pattern.properties,
+  Array_exports.findFirst(
+    (property) => property.type === "RestElement" && property.argument.type === "Identifier" ? Option_exports.some(property.argument.name) : Option_exports.none()
+  )
+);
+var withoutDefault = (value) => value.type === "AssignmentPattern" ? value.left : value;
+var bindingDiagnostic = (execute, bindingName) => {
+  if (bindingName.startsWith("_")) {
+    return Option_exports.some(ignoredElementBindingMessage(bindingName));
+  }
+  return referencesName(execute.body, bindingName) ? Option_exports.none() : Option_exports.some(unusedElementBindingMessage(bindingName));
+};
+var unpackedDiagnostic = (execute, bindingName) => {
+  const uses = inputUses(execute.body, bindingName);
+  if (Array_exports.isReadonlyArrayEmpty(uses)) {
+    return Option_exports.some(unusedInputMessage(bindingName));
+  }
+  return uses.every((use) => use === "OtherField") ? Option_exports.some(unreadElementFieldMessage(bindingName)) : Option_exports.none();
+};
+var executeDiagnostic = (execute) => {
+  const [firstParameter] = execute.params;
+  if (firstParameter === void 0) {
+    return Option_exports.some(NO_ELEMENT_BINDING_MESSAGE);
+  }
+  if (firstParameter.type === "Identifier") {
+    return unpackedDiagnostic(execute, firstParameter.name);
+  }
+  if (firstParameter.type !== "ObjectPattern") {
+    return Option_exports.some(NO_ELEMENT_BINDING_MESSAGE);
+  }
+  return Option_exports.match(elementProperty(firstParameter), {
+    onNone: () => Option_exports.match(restBindingName(firstParameter), {
+      onNone: () => Option_exports.some(NO_ELEMENT_BINDING_MESSAGE),
+      onSome: (restName) => unpackedDiagnostic(execute, restName)
+    }),
+    onSome: (property) => {
+      const pattern = withoutDefault(property.value);
+      return pattern.type === "Identifier" ? bindingDiagnostic(execute, pattern.name) : Option_exports.none();
+    }
+  });
+};
+var executeFunction = (node) => pipe(
+  Array_exports.get(node.arguments, 1),
+  Option_exports.filter(isObjectExpression),
+  Option_exports.flatMap((config) => AST_exports.objectGetValue(config, "execute")),
+  Option_exports.filter(isExecuteFunction)
+);
 var mountFactoryMustUseElement = Rule_exports.define({
   name: "mount-factory-must-use-element",
   meta: Rule_exports.meta({
     type: "suggestion",
-    description: "Require Mount factories to use their live element."
+    description: "Require a Mount's execute to use its live element."
   }),
   create: function* () {
     const ctx = yield* RuleContext;
     return {
       CallExpression: (node) => {
-        if (!isCallExpression(node)) return Effect_exports.void;
-        if (node.callee.type !== "CallExpression" || !isMountDefinitionChain(node.callee)) {
-          return Effect_exports.void;
-        }
-        const [factoryArgument] = node.arguments;
-        if (factoryArgument === void 0 || !isFactoryFunction(factoryArgument)) {
+        if (!isCallExpression(node) || !AST_exports.isCallOf(node, "Mount", MOUNT_DEFINITION_METHODS)) {
           return Effect_exports.void;
         }
-        const elementFactory = descendToElementFactory(factoryArgument);
-        return Option_exports.match(elementFactoryDiagnostic(elementFactory), {
+        return Option_exports.match(executeFunction(node), {
           onNone: () => Effect_exports.void,
-          onSome: (message) => ctx.report(Diagnostic_exports.make({ node: elementFactory, message }))
+          onSome: (execute) => Option_exports.match(executeDiagnostic(execute), {
+            onNone: () => Effect_exports.void,
+            onSome: (message) => ctx.report(Diagnostic_exports.make({ node: execute, message }))
+          })
         });
       }
     };
@@ -11456,7 +11521,7 @@ var noDisablingDevGuardrails = Rule_exports.define({
 });
 
 // src/rules/no-duplicate-onmount-per-element.ts
-var DUPLICATE_ON_MOUNT_MESSAGE = "Only one OnMount attribute can attach to an element. Foldkit installs a single insert hook and tracks a single Mount fiber per element, so a later OnMount replaces the earlier one and its factory never runs. Combine the behaviors into one Mount definition.";
+var DUPLICATE_ON_MOUNT_MESSAGE = "Only one OnMount attribute can attach to an element. Foldkit installs a single insert hook and tracks a single Mount fiber per element, so a later OnMount replaces the earlier one and its `execute` never runs. Combine the behaviors into one Mount definition.";
 var isOnMountCallee = (callee) => {
   if (callee.type === "Identifier") {
     return callee.name === "OnMount";
@@ -11784,14 +11849,7 @@ var noEmptyChildrenArray = Rule_exports.define({
 
 // src/rules/no-empty-commands-array.ts
 var COMMANDS_PROPERTY = "commands";
-var isObjectProperty = (node) => typeof node === "object" && node !== null && "type" in node && node.type === "Property";
-var staticPropertyName2 = (property) => {
-  if (!property.computed && isIdentifier(property.key)) {
-    return Option_exports.some(property.key.name);
-  }
-  return staticStringValue(property.key);
-};
-var isEmptyCommandsProperty = (property) => Option_exports.contains(staticPropertyName2(property), COMMANDS_PROPERTY) && isArrayExpression(property.value) && Array_exports.isReadonlyArrayEmpty(property.value.elements);
+var isEmptyCommandsProperty = (property) => Option_exports.contains(staticPropertyName(property), COMMANDS_PROPERTY) && isArrayExpression(property.value) && Array_exports.isReadonlyArrayEmpty(property.value.elements);
 var removalRange = (sourceText, object, property, index) => {
   const maybePrevious = Array_exports.get(object.properties, index - 1);
   if (Option_exports.isSome(maybePrevious)) {
@@ -11832,11 +11890,11 @@ var noEmptyCommandsArray = Rule_exports.define({
         );
         const hasDynamicComputedProperty = Array_exports.some(
           node.properties,
-          (property) => isObjectProperty(property) && property.computed && Option_exports.isNone(staticPropertyName2(property))
+          (property) => isObjectProperty(property) && property.computed && Option_exports.isNone(staticPropertyName(property))
         );
         const commandProperties = Array_exports.filter(
           node.properties,
-          (property) => isObjectProperty(property) && Option_exports.contains(staticPropertyName2(property), COMMANDS_PROPERTY)
+          (property) => isObjectProperty(property) && Option_exports.contains(staticPropertyName(property), COMMANDS_PROPERTY)
         );
         const hasComments = Array_exports.isReadonlyArrayNonEmpty(
           ctx.sourceCode.getCommentsInside(node)
@@ -11952,35 +12010,14 @@ var noEmptyObjectTaggedCall = Rule_exports.define({
 
 // src/rules/no-empty-to-parent-out-message.ts
 var TO_PARENT_OUT_MESSAGE_PROPERTY = "toParentOutMessage";
-var isObjectProperty2 = (node) => typeof node === "object" && node !== null && "type" in node && node.type === "Property";
-var staticPropertyName3 = (property) => {
-  if (!property.computed && isIdentifier(property.key)) {
-    return Option_exports.some(property.key.name);
-  }
-  return staticStringValue(property.key);
-};
 var isArrowFunctionExpression3 = (node) => typeof node === "object" && node !== null && "type" in node && node.type === "ArrowFunctionExpression";
 var isFunctionExpression = (node) => typeof node === "object" && node !== null && "type" in node && node.type === "FunctionExpression";
 var isMapperFunction = (node) => isArrowFunctionExpression3(node) && !node.async || isFunctionExpression(node) && !node.async && !node.generator;
-var isIdentifierReference = (node) => isIdentifier(node);
-var indexReferences = (scopes) => {
-  const references = /* @__PURE__ */ new WeakMap();
-  for (const scope3 of scopes) {
-    for (const reference of scope3.references) {
-      references.set(reference.identifier, reference);
-    }
-  }
-  return references;
-};
 var isUnshadowedUndefined = (references, node) => {
   if (!isIdentifierReference(node) || node.name !== "undefined") {
     return false;
   }
-  if (references === void 0) {
-    return true;
-  }
-  const reference = references.get(node);
-  return reference !== void 0 && (reference.resolved === null || Array_exports.isArrayEmpty(reference.resolved.defs));
+  return isUnshadowedReference(references, node);
 };
 var directlyReturnsUndefined = (references, mapper) => {
   if (mapper.body === null) {
@@ -11993,7 +12030,7 @@ var directlyReturnsUndefined = (references, mapper) => {
   return firstStatement?.type === "ReturnStatement" && secondStatement === void 0 && isUnshadowedUndefined(references, firstStatement.argument);
 };
 var isEmptyMapperProperty = (references, property) => property.kind === "init" && Option_exports.contains(
-  staticPropertyName3(property),
+  staticPropertyName(property),
   TO_PARENT_OUT_MESSAGE_PROPERTY
 ) && isMapperFunction(property.value) && directlyReturnsUndefined(references, property.value);
 var removalRange2 = (sourceText, object, property, index) => {
@@ -12038,12 +12075,12 @@ var noEmptyToParentOutMessage = Rule_exports.define({
         );
         const hasDynamicComputedProperty = Array_exports.some(
           node.properties,
-          (property) => isObjectProperty2(property) && property.computed && Option_exports.isNone(staticPropertyName3(property))
+          (property) => isObjectProperty(property) && property.computed && Option_exports.isNone(staticPropertyName(property))
         );
         const mapperProperties = Array_exports.filter(
           node.properties,
-          (property) => isObjectProperty2(property) && Option_exports.contains(
-            staticPropertyName3(property),
+          (property) => isObjectProperty(property) && Option_exports.contains(
+            staticPropertyName(property),
             TO_PARENT_OUT_MESSAGE_PROPERTY
           )
         );
@@ -12053,7 +12090,7 @@ var noEmptyToParentOutMessage = Rule_exports.define({
         return Effect_exports.forEach(
           node.properties.entries(),
           ([index, property]) => {
-            if (!isObjectProperty2(property) || !isEmptyMapperProperty(references, property)) {
+            if (!isObjectProperty(property) || !isEmptyMapperProperty(references, property)) {
               return Effect_exports.void;
             }
             const diagnostic = Diagnostic_exports.make({
@@ -12216,6 +12253,628 @@ var noHardcodedRouteStrings = Rule_exports.define({
   }
 });
 
+// src/rules/no-impure-call-at-decision-time.ts
+var globalContainers = /* @__PURE__ */ new Set(["globalThis", "self", "window"]);
+var impureCallByPath = /* @__PURE__ */ new Map([
+  [
+    "Date",
+    {
+      display: "Date()",
+      guidance: "Use Clock.currentTimeMillis and construct the Date from that value."
+    }
+  ],
+  [
+    "Date.now",
+    {
+      display: "Date.now()",
+      guidance: "Use Clock.currentTimeMillis."
+    }
+  ],
+  [
+    "Math.random",
+    {
+      display: "Math.random()",
+      guidance: "Use Random."
+    }
+  ],
+  [
+    "performance.now",
+    {
+      display: "performance.now()",
+      guidance: "Use Clock."
+    }
+  ],
+  [
+    "crypto.randomUUID",
+    {
+      display: "crypto.randomUUID()",
+      guidance: "Use Crypto.Crypto's randomUUIDv4 Effect with a platform Crypto layer."
+    }
+  ],
+  [
+    "crypto.getRandomValues",
+    {
+      display: "crypto.getRandomValues()",
+      guidance: "Use Random or Crypto.Crypto with a platform Crypto layer."
+    }
+  ]
+]);
+var newDateOperation = {
+  display: "new Date()",
+  guidance: "Use Clock.currentTimeMillis and construct the Date from that value."
+};
+var isFunction2 = (node) => typeof node === "object" && node !== null && "type" in node && (node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression" || node.type === "FunctionDeclaration");
+var isTransparentExpression = (node) => {
+  if (typeof node !== "object" || node === null || !("type" in node)) {
+    return false;
+  }
+  return node.type === "ChainExpression" || node.type === "ParenthesizedExpression" || node.type === "TSAsExpression" || node.type === "TSInstantiationExpression" || node.type === "TSNonNullExpression" || node.type === "TSSatisfiesExpression" || node.type === "TSTypeAssertion";
+};
+var innermostExpression = (node) => isTransparentExpression(node) ? innermostExpression(node.expression) : node;
+var outermostExpression = (node) => {
+  const parent = node.parent;
+  return isTransparentExpression(parent) && parent.expression === node ? outermostExpression(parent) : node;
+};
+var staticPath = (node) => {
+  const expression = innermostExpression(node);
+  if (isIdentifierReference(expression)) {
+    return Option_exports.some({ root: expression, members: [] });
+  }
+  if (!isMemberExpression(expression)) {
+    return Option_exports.none();
+  }
+  return Option_exports.flatMap(
+    staticPath(expression.object),
+    (path) => Option_exports.map(staticMemberName(expression), (member) => ({
+      root: path.root,
+      members: [...path.members, member]
+    }))
+  );
+};
+var globalPathKey = (references, node) => Option_exports.flatMap(staticPath(node), (path) => {
+  if (!isUnshadowedReference(references, path.root)) {
+    return Option_exports.none();
+  }
+  const members = globalContainers.has(path.root.name) ? path.members : [path.root.name, ...path.members];
+  return Option_exports.some(members.join("."));
+});
+var importedName = (node) => node.imported.type === "Identifier" ? Option_exports.some(node.imported.name) : Option_exports.some(node.imported.value);
+var importedPath = (references, node) => Option_exports.flatMap(staticPath(node), (path) => {
+  if (references === void 0) {
+    return Option_exports.some({
+      source: "",
+      members: [path.root.name, ...path.members]
+    });
+  }
+  const reference = references.get(path.root);
+  const maybeDefinition = Option_exports.flatMap(
+    Option_exports.fromNullishOr(reference?.resolved),
+    (variable) => Array_exports.findFirst(
+      variable.defs,
+      (definition) => definition.type === "ImportBinding"
+    )
+  );
+  return Option_exports.flatMap(maybeDefinition, (definition) => {
+    if (definition.parent?.type !== "ImportDeclaration") {
+      return Option_exports.none();
+    }
+    const source = definition.parent.source.value;
+    if (definition.node.type === "ImportNamespaceSpecifier") {
+      return Option_exports.some({ source, members: path.members });
+    }
+    if (definition.node.type !== "ImportSpecifier") {
+      return Option_exports.none();
+    }
+    return Option_exports.map(importedName(definition.node), (name) => ({
+      source,
+      members: [name, ...path.members]
+    }));
+  });
+});
+var normalizedApiPath = (path) => {
+  if (path.source === "" || path.source === "effect" || path.source === "foldkit") {
+    return Option_exports.some(path.members);
+  }
+  if (path.source === "effect/Effect") {
+    return Option_exports.some(["Effect", ...path.members]);
+  }
+  if (path.source === "effect/Stream") {
+    return Option_exports.some(["Stream", ...path.members]);
+  }
+  if (path.source === "foldkit/command") {
+    return Option_exports.some(["Command", ...path.members]);
+  }
+  if (path.source === "foldkit/managedResource") {
+    return Option_exports.some(["ManagedResource", ...path.members]);
+  }
+  if (path.source === "foldkit/mount") {
+    return Option_exports.some(["Mount", ...path.members]);
+  }
+  if (path.source === "foldkit/subscription") {
+    return Option_exports.some(["Subscription", ...path.members]);
+  }
+  return Option_exports.none();
+};
+var headCall = (node) => node.callee.type === "CallExpression" ? headCall(node.callee) : node;
+var apiCallKey = (references, node) => Option_exports.flatMap(
+  importedPath(references, headCall(node).callee),
+  (path) => Option_exports.map(normalizedApiPath(path), (members) => members.join("."))
+);
+var enclosingCallArgument = (node) => {
+  const argument = outermostExpression(node);
+  const parent = argument.parent;
+  return parent?.type === "CallExpression" && parent.arguments.some((candidate) => candidate === argument) ? Option_exports.some({ call: parent, argument }) : Option_exports.none();
+};
+var enclosingPropertyValue = (node) => {
+  const value = outermostExpression(node);
+  const parent = value.parent;
+  return isObjectProperty(parent) && parent.value === value ? Option_exports.some(parent) : Option_exports.none();
+};
+var effectFunctionFactories = /* @__PURE__ */ new Set(["Effect.fn", "Effect.fnUntraced"]);
+var directByArity = (...entries) => new Map(
+  entries.map(([arity, ...argumentIndices]) => [
+    arity,
+    new Set(argumentIndices)
+  ])
+);
+var propertiesByArity = (...entries) => {
+  const properties2 = /* @__PURE__ */ new Map();
+  for (const [arity, argumentIndex, ...propertyNames] of entries) {
+    const byArgument = properties2.get(arity) ?? /* @__PURE__ */ new Map();
+    byArgument.set(
+      argumentIndex,
+      Array_exports.isArrayEmpty(propertyNames) ? true : new Set(propertyNames)
+    );
+    properties2.set(arity, byArgument);
+  }
+  return properties2;
+};
+var direct = (...entries) => ({ direct: directByArity(...entries) });
+var properties = (...entries) => ({
+  properties: propertiesByArity(...entries)
+});
+var unaryCallback = direct([1, 0]);
+var unaryDualCallback = direct([1, 0], [2, 1]);
+var unaryDualCallbackWithOptions = direct([1, 0], [2, 0, 1], [3, 1]);
+var binaryDualCallback = direct([2, 1], [3, 2]);
+var binaryDualCallbackWithOptions = direct([2, 1], [3, 1, 2], [4, 2]);
+var successAndFailureProperties = properties(
+  [1, 0, "onFailure", "onSuccess"],
+  [2, 1, "onFailure", "onSuccess"]
+);
+var taggedCallback = direct([2, 1], [3, 1, 2], [4, 2, 3]);
+var taggedCallbackMap = {
+  direct: directByArity([2, 1], [3, 2]),
+  properties: propertiesByArity([1, 0], [2, 0], [2, 1], [3, 1])
+};
+var reasonCallback = direct([3, 2], [4, 2, 3], [5, 3, 4]);
+var reasonCallbackMap = {
+  direct: directByArity([3, 2], [4, 3]),
+  properties: propertiesByArity([2, 1], [3, 1], [3, 2], [4, 2])
+};
+var predicateAndCallback = direct([2, 0, 1], [3, 0, 1, 2], [4, 1, 2, 3]);
+var deferredCallbackByApi = /* @__PURE__ */ new Map([
+  ["Effect.acquireRelease", direct([2, 1], [3, 1])],
+  ["Effect.acquireUseRelease", direct([3, 1, 2])],
+  ["Effect.addFinalizer", unaryCallback],
+  ["Effect.andThen", unaryDualCallback],
+  ["Effect.bind", binaryDualCallback],
+  ["Effect.callback", unaryCallback],
+  ["Effect.catch", unaryDualCallback],
+  ["Effect.catchCause", unaryDualCallback],
+  ["Effect.catchCauseFilter", predicateAndCallback],
+  ["Effect.catchCauseIf", predicateAndCallback],
+  ["Effect.catchDefect", unaryDualCallback],
+  ["Effect.catchFilter", predicateAndCallback],
+  ["Effect.catchIf", predicateAndCallback],
+  ["Effect.catchReason", reasonCallback],
+  ["Effect.catchReasons", reasonCallbackMap],
+  ["Effect.catchTag", taggedCallback],
+  ["Effect.catchTags", taggedCallbackMap],
+  ["Effect.clockWith", unaryCallback],
+  ["Effect.contextWith", unaryCallback],
+  ["Effect.effectify", direct([1, 0], [2, 0, 1], [3, 0, 1, 2])],
+  ["Effect.failCauseSync", unaryCallback],
+  ["Effect.failSync", unaryCallback],
+  ["Effect.filter", unaryDualCallbackWithOptions],
+  ["Effect.filterMap", unaryDualCallback],
+  ["Effect.filterMapEffect", unaryDualCallbackWithOptions],
+  ["Effect.filterMapOrElse", direct([2, 0, 1], [3, 1, 2])],
+  ["Effect.filterMapOrFail", direct([1, 0], [2, 0, 1], [3, 1, 2])],
+  ["Effect.filterOrElse", direct([2, 0, 1], [3, 1, 2])],
+  ["Effect.filterOrFail", direct([1, 0], [2, 0, 1], [3, 1, 2])],
+  ["Effect.findFirst", unaryDualCallback],
+  ["Effect.findFirstFilter", unaryDualCallback],
+  ["Effect.flatMap", unaryDualCallback],
+  ["Effect.forEach", unaryDualCallbackWithOptions],
+  ["Effect.gen", direct([1, 0], [2, 1])],
+  ["Effect.interruptibleMask", unaryCallback],
+  ["Effect.let", binaryDualCallback],
+  ["Effect.map", unaryDualCallback],
+  ["Effect.mapBoth", successAndFailureProperties],
+  ["Effect.mapError", unaryDualCallback],
+  ["Effect.match", successAndFailureProperties],
+  ["Effect.matchCause", successAndFailureProperties],
+  ["Effect.matchCauseEffect", successAndFailureProperties],
+  ["Effect.matchEffect", successAndFailureProperties],
+  ["Effect.onError", unaryDualCallback],
+  ["Effect.onErrorFilter", predicateAndCallback],
+  ["Effect.onErrorIf", predicateAndCallback],
+  ["Effect.onExit", unaryDualCallback],
+  ["Effect.onExitFilter", predicateAndCallback],
+  ["Effect.onExitIf", predicateAndCallback],
+  ["Effect.onExitPrimitive", direct([2, 1], [3, 1])],
+  ["Effect.onInterrupt", unaryDualCallback],
+  ["Effect.orElseSucceed", unaryDualCallback],
+  ["Effect.partition", unaryDualCallbackWithOptions],
+  ["Effect.promise", unaryCallback],
+  ["Effect.reduce", direct([2, 0, 1], [3, 1, 2])],
+  [
+    "Effect.repeat",
+    properties([1, 0, "while", "until"], [2, 1, "while", "until"])
+  ],
+  ["Effect.repeatOrElse", binaryDualCallback],
+  [
+    "Effect.retry",
+    properties([1, 0, "while", "until"], [2, 1, "while", "until"])
+  ],
+  ["Effect.retryOrElse", binaryDualCallback],
+  ["Effect.scopedWith", unaryCallback],
+  ["Effect.suspend", unaryCallback],
+  ["Effect.sync", unaryCallback],
+  ["Effect.tap", unaryDualCallback],
+  ["Effect.tapCause", unaryDualCallback],
+  ["Effect.tapCauseFilter", predicateAndCallback],
+  ["Effect.tapCauseIf", predicateAndCallback],
+  ["Effect.tapDefect", unaryDualCallback],
+  ["Effect.tapError", unaryDualCallback],
+  ["Effect.tapErrorTag", taggedCallback],
+  ["Effect.timeoutOrElse", properties([1, 0, "orElse"], [2, 1, "orElse"])],
+  ["Effect.track", direct([2, 1], [3, 2])],
+  ["Effect.trackDefects", direct([2, 1], [3, 2])],
+  ["Effect.trackDuration", direct([2, 1], [3, 2])],
+  ["Effect.trackErrors", direct([2, 1], [3, 2])],
+  ["Effect.trackSuccesses", direct([2, 1], [3, 2])],
+  [
+    "Effect.try",
+    {
+      direct: directByArity([1, 0]),
+      properties: propertiesByArity([1, 0, "try", "catch"])
+    }
+  ],
+  [
+    "Effect.tryPromise",
+    {
+      direct: directByArity([1, 0]),
+      properties: propertiesByArity([1, 0, "try", "catch"])
+    }
+  ],
+  ["Effect.uninterruptibleMask", unaryCallback],
+  ["Effect.updateContext", unaryDualCallback],
+  ["Effect.updateService", binaryDualCallback],
+  [
+    "Effect.updateServiceScoped",
+    {
+      direct: directByArity([2, 1], [3, 1]),
+      properties: propertiesByArity([3, 2, "reset"])
+    }
+  ],
+  ["Effect.useSpan", direct([2, 1], [3, 2])],
+  ["Effect.validate", unaryDualCallbackWithOptions],
+  ["Effect.whileLoop", properties([1, 0, "while", "body", "step"])],
+  [
+    "Effect.withExecutionPlan",
+    properties([2, 1, "onEvent"], [3, 2, "onEvent"])
+  ],
+  ["Effect.withFiber", unaryCallback],
+  ["Effect.zipWith", binaryDualCallbackWithOptions],
+  ["Effect.race", properties([2, 1, "onWinner"], [3, 2, "onWinner"])],
+  ["Effect.raceFirst", properties([2, 1, "onWinner"], [3, 2, "onWinner"])],
+  ["Effect.raceAll", properties([2, 1, "onWinner"])],
+  ["Effect.raceAllFirst", properties([2, 1, "onWinner"])],
+  ["Stream.bind", binaryDualCallbackWithOptions],
+  ["Stream.bindEffect", binaryDualCallbackWithOptions],
+  ["Stream.callback", unaryCallback],
+  ["Stream.catch", unaryDualCallback],
+  ["Stream.catchCause", unaryDualCallback],
+  ["Stream.catchCauseFilter", predicateAndCallback],
+  ["Stream.catchCauseIf", predicateAndCallback],
+  ["Stream.catchFilter", predicateAndCallback],
+  ["Stream.catchIf", predicateAndCallback],
+  ["Stream.catchReason", reasonCallback],
+  ["Stream.catchReasons", reasonCallbackMap],
+  ["Stream.catchTag", taggedCallback],
+  ["Stream.catchTags", taggedCallbackMap],
+  ["Stream.changesWith", unaryDualCallback],
+  ["Stream.changesWithEffect", unaryDualCallback],
+  ["Stream.combine", direct([3, 1, 2], [4, 2, 3])],
+  ["Stream.combineArray", direct([3, 1, 2], [4, 2, 3])],
+  ["Stream.crossWith", binaryDualCallback],
+  ["Stream.dropUntil", unaryDualCallback],
+  ["Stream.dropUntilEffect", unaryDualCallback],
+  ["Stream.dropWhile", unaryDualCallback],
+  ["Stream.dropWhileEffect", unaryDualCallback],
+  ["Stream.dropWhileFilter", unaryDualCallback],
+  ["Stream.failCauseSync", unaryCallback],
+  ["Stream.failSync", unaryCallback],
+  ["Stream.filter", unaryDualCallback],
+  ["Stream.filterEffect", unaryDualCallback],
+  ["Stream.filterMap", unaryDualCallback],
+  ["Stream.filterMapEffect", unaryDualCallback],
+  ["Stream.flatMap", unaryDualCallbackWithOptions],
+  ["Stream.fromAsyncIterable", direct([2, 1])],
+  ["Stream.fromReadableStream", properties([1, 0, "evaluate", "onError"])],
+  ["Stream.groupAdjacentBy", unaryDualCallback],
+  ["Stream.groupBy", unaryDualCallbackWithOptions],
+  ["Stream.groupByKey", unaryDualCallbackWithOptions],
+  ["Stream.iterate", direct([2, 1])],
+  ["Stream.limitBytes", direct([2, 1], [3, 2])],
+  ["Stream.map", unaryDualCallback],
+  [
+    "Stream.mapAccum",
+    {
+      direct: directByArity([2, 0, 1], [3, 0, 1, 2], [4, 1, 2]),
+      properties: propertiesByArity([3, 2, "onHalt"], [4, 3, "onHalt"])
+    }
+  ],
+  [
+    "Stream.mapAccumArray",
+    {
+      direct: directByArity([2, 0, 1], [3, 0, 1, 2], [4, 1, 2]),
+      properties: propertiesByArity([3, 2, "onHalt"], [4, 3, "onHalt"])
+    }
+  ],
+  [
+    "Stream.mapAccumArrayEffect",
+    {
+      direct: directByArity([2, 0, 1], [3, 0, 1, 2], [4, 1, 2]),
+      properties: propertiesByArity([3, 2, "onHalt"], [4, 3, "onHalt"])
+    }
+  ],
+  [
+    "Stream.mapAccumEffect",
+    {
+      direct: directByArity([2, 0, 1], [3, 0, 1, 2], [4, 1, 2]),
+      properties: propertiesByArity([3, 2, "onHalt"], [4, 3, "onHalt"])
+    }
+  ],
+  ["Stream.mapArray", unaryDualCallback],
+  ["Stream.mapArrayEffect", unaryDualCallback],
+  ["Stream.mapBoth", successAndFailureProperties],
+  ["Stream.mapEffect", unaryDualCallbackWithOptions],
+  ["Stream.mapError", unaryDualCallback],
+  ["Stream.let", binaryDualCallback],
+  ["Stream.onError", unaryDualCallback],
+  ["Stream.onExit", unaryDualCallback],
+  ["Stream.onFirst", unaryDualCallback],
+  ["Stream.orElseIfEmpty", unaryDualCallback],
+  ["Stream.orElseSucceed", unaryDualCallback],
+  ["Stream.paginate", direct([2, 1])],
+  ["Stream.partition", unaryDualCallbackWithOptions],
+  ["Stream.partitionEffect", unaryDualCallbackWithOptions],
+  ["Stream.partitionQueue", unaryDualCallbackWithOptions],
+  ["Stream.runFold", direct([2, 0, 1], [3, 1, 2])],
+  ["Stream.runFoldEffect", direct([2, 0, 1], [3, 1, 2])],
+  ["Stream.runForEach", unaryDualCallback],
+  ["Stream.runForEachArray", unaryDualCallback],
+  ["Stream.runForEachWhile", unaryDualCallback],
+  ["Stream.scan", direct([2, 1], [3, 2])],
+  ["Stream.scanEffect", direct([2, 1], [3, 2])],
+  ["Stream.split", unaryDualCallback],
+  ["Stream.suspend", unaryCallback],
+  ["Stream.switchMap", unaryDualCallbackWithOptions],
+  ["Stream.sync", unaryCallback],
+  ["Stream.takeUntil", unaryDualCallbackWithOptions],
+  ["Stream.takeUntilEffect", unaryDualCallbackWithOptions],
+  ["Stream.takeWhile", unaryDualCallback],
+  ["Stream.takeWhileEffect", unaryDualCallback],
+  ["Stream.takeWhileFilter", unaryDualCallback],
+  ["Stream.tap", unaryDualCallbackWithOptions],
+  [
+    "Stream.tapBoth",
+    properties([1, 0, "onElement", "onError"], [2, 1, "onElement", "onError"])
+  ],
+  ["Stream.tapCause", unaryDualCallback],
+  ["Stream.tapError", unaryDualCallback],
+  ["Stream.throttle", properties([1, 0, "cost"], [2, 1, "cost"])],
+  ["Stream.throttleEffect", properties([1, 0, "cost"], [2, 1, "cost"])],
+  ["Stream.timeoutOrElse", properties([1, 0, "orElse"], [2, 1, "orElse"])],
+  ["Stream.transformPull", direct([2, 1])],
+  ["Stream.transformPullBracket", direct([2, 1])],
+  ["Stream.unfold", direct([2, 1])],
+  ["Stream.updateContext", unaryDualCallback],
+  ["Stream.updateService", binaryDualCallback],
+  [
+    "Stream.withExecutionPlan",
+    properties([2, 1, "onEvent"], [3, 2, "onEvent"])
+  ],
+  ["Stream.zipLatestWith", binaryDualCallback],
+  ["Stream.zipWith", binaryDualCallback],
+  ["Stream.zipWithArray", binaryDualCallback]
+]);
+var isEffectFunctionBody = (argument, call) => {
+  const maybeFirstArgument = Array_exports.head(call.arguments);
+  if (Option_exports.contains(maybeFirstArgument, argument)) {
+    return true;
+  }
+  return Option_exports.exists(
+    maybeFirstArgument,
+    (argument2) => isObjectExpression(innermostExpression(argument2))
+  ) && Option_exports.contains(Array_exports.get(call.arguments, 1), argument);
+};
+var isDeferredDirectEffectApiCallback = (argument, call, key) => {
+  if (effectFunctionFactories.has(key)) {
+    return isEffectFunctionBody(argument, call);
+  }
+  const maybeArgumentIndex = Array_exports.findFirstIndex(
+    call.arguments,
+    (candidate) => candidate === argument
+  );
+  const maybePositions = Option_exports.fromNullishOr(
+    deferredCallbackByApi.get(key)?.direct?.get(call.arguments.length)
+  );
+  return Option_exports.exists(
+    maybeArgumentIndex,
+    (argumentIndex) => Option_exports.exists(maybePositions, (positions) => positions.has(argumentIndex))
+  );
+};
+var isDeferredObjectEffectApiCallback = (property, argument, call, key) => {
+  const maybeArgumentIndex = Array_exports.findFirstIndex(
+    call.arguments,
+    (candidate) => candidate === argument
+  );
+  const maybePropertyName = staticPropertyName(property);
+  const propertiesByArgument = deferredCallbackByApi.get(key)?.properties?.get(call.arguments.length);
+  return Option_exports.exists(maybeArgumentIndex, (argumentIndex) => {
+    const propertyNames = propertiesByArgument?.get(argumentIndex);
+    return propertyNames === true || propertyNames !== void 0 && Option_exports.exists(
+      maybePropertyName,
+      (propertyName) => propertyNames.has(propertyName)
+    );
+  });
+};
+var isEffectOrStreamCallback = (references, fn3) => {
+  const maybeDirectCall = enclosingCallArgument(fn3);
+  if (Option_exports.isSome(maybeDirectCall)) {
+    return Option_exports.exists(
+      apiCallKey(references, maybeDirectCall.value.call),
+      (key) => isDeferredDirectEffectApiCallback(
+        maybeDirectCall.value.argument,
+        maybeDirectCall.value.call,
+        key
+      )
+    );
+  }
+  const maybeProperty = enclosingPropertyValue(fn3);
+  if (Option_exports.isNone(maybeProperty)) {
+    return false;
+  }
+  const property = maybeProperty.value;
+  const object = property.parent;
+  if (object.type !== "ObjectExpression") {
+    return false;
+  }
+  const maybeCall = enclosingCallArgument(object);
+  if (Option_exports.isNone(maybeCall)) {
+    return false;
+  }
+  const { argument, call } = maybeCall.value;
+  return Option_exports.exists(
+    apiCallKey(references, call),
+    (key) => isDeferredObjectEffectApiCallback(property, argument, call, key)
+  );
+};
+var isInlineConfigFunction = (references, fn3, propertyNames, factoryKeys) => {
+  const maybeProperty = enclosingPropertyValue(fn3);
+  if (Option_exports.isNone(maybeProperty)) {
+    return false;
+  }
+  const property = maybeProperty.value;
+  if (property.parent.type !== "ObjectExpression" || !Option_exports.exists(
+    staticPropertyName(property),
+    (name) => propertyNames.has(name)
+  )) {
+    return false;
+  }
+  const maybeCall = enclosingCallArgument(property.parent);
+  if (Option_exports.isNone(maybeCall)) {
+    return false;
+  }
+  return Option_exports.exists(
+    apiCallKey(references, maybeCall.value.call),
+    (key) => factoryKeys.has(key)
+  );
+};
+var hasFactoryAncestor = (references, node, factoryKey) => {
+  const parent = node.parent;
+  if (parent === null) {
+    return false;
+  }
+  if (parent.type === "CallExpression" && Option_exports.contains(apiCallKey(references, parent), factoryKey)) {
+    return true;
+  }
+  return hasFactoryAncestor(references, parent, factoryKey);
+};
+var isNestedLifecycleFunction = (references, fn3) => {
+  const maybeProperty = enclosingPropertyValue(fn3);
+  if (Option_exports.isNone(maybeProperty)) {
+    return false;
+  }
+  const property = maybeProperty.value;
+  if (property.parent.type !== "ObjectExpression") {
+    return false;
+  }
+  if (Option_exports.isNone(enclosingCallArgument(property.parent))) {
+    return false;
+  }
+  const maybePropertyName = staticPropertyName(property);
+  const isSubscriptionEffect = Option_exports.contains(
+    maybePropertyName,
+    "dependenciesToStream"
+  );
+  if (isSubscriptionEffect && hasFactoryAncestor(references, fn3, "Subscription.make")) {
+    return true;
+  }
+  const isManagedResourceEffect = Option_exports.exists(
+    maybePropertyName,
+    (name) => name === "acquire" || name === "release"
+  );
+  return isManagedResourceEffect && hasFactoryAncestor(references, fn3, "ManagedResource.make");
+};
+var commandAndMountEffectProperties = /* @__PURE__ */ new Set(["execute"]);
+var commandAndMountFactories = /* @__PURE__ */ new Set([
+  "Command.define",
+  "Mount.define",
+  "Mount.defineStream"
+]);
+var isDeferredFunction = (references, fn3) => isEffectOrStreamCallback(references, fn3) || isInlineConfigFunction(
+  references,
+  fn3,
+  commandAndMountEffectProperties,
+  commandAndMountFactories
+) || isNestedLifecycleFunction(references, fn3);
+var isInsideEffectBoundary = (references, node) => {
+  const parent = node.parent;
+  if (parent === null) {
+    return false;
+  }
+  if (isFunction2(parent) && isDeferredFunction(references, parent)) {
+    return true;
+  }
+  return isInsideEffectBoundary(references, parent);
+};
+var callOperation = (references, node) => Option_exports.flatMap(
+  globalPathKey(references, node.callee),
+  (key) => Option_exports.fromNullishOr(impureCallByPath.get(key))
+);
+var newOperation = (references, node) => Array_exports.isArrayEmpty(node.arguments) && Option_exports.contains(globalPathKey(references, node.callee), "Date") ? Option_exports.some(newDateOperation) : Option_exports.none();
+var diagnosticMessage2 = ({ display, guidance }) => `${display} is outside a recognized callback that Effect or Foldkit defers until execution. ${guidance} Obtain the value in a deferred Effect or lifecycle execution callback and return it in a Message. Assigning it to a local variable or passing it as a Command argument does not defer the call.`;
+var noImpureCallAtDecisionTime = Rule_exports.define({
+  name: "no-impure-call-at-decision-time",
+  meta: Rule_exports.meta({
+    type: "problem",
+    description: "Keep direct time and randomness calls inside deferred Effect and lifecycle execution callbacks."
+  }),
+  create: function* () {
+    const ctx = yield* RuleContext;
+    const scopes = ctx.sourceCode.scopeManager?.scopes;
+    const references = scopes === void 0 ? void 0 : indexReferences(scopes);
+    const report = (node, maybeOperation) => Option_exports.match(maybeOperation, {
+      onNone: () => Effect_exports.void,
+      onSome: (operation) => isInsideEffectBoundary(references, node) ? Effect_exports.void : ctx.report(
+        Diagnostic_exports.make({
+          node,
+          message: diagnosticMessage2(operation)
+        })
+      )
+    });
+    return {
+      CallExpression: (node) => node.type === "CallExpression" ? report(node, callOperation(references, node)) : Effect_exports.void,
+      NewExpression: (node) => node.type === "NewExpression" ? report(node, newOperation(references, node)) : Effect_exports.void
+    };
+  }
+});
+
 // src/rules/no-module-level-mutable-state.ts
 var isMutableDeclaration = (node) => (node.kind === "let" || node.kind === "var") && node.declare !== true;
 var topLevelMutableDeclarations = (program) => program.body.flatMap((statement) => {
@@ -12285,24 +12944,6 @@ var isInsideTypeQuery = (node) => {
   }
   return false;
 };
-var staticMemberName = (node) => {
-  if (!node.computed && node.property.type === "Identifier") {
-    return node.property.name;
-  }
-  if (node.computed && node.property.type === "Literal" && typeof node.property.value === "string") {
-    return node.property.value;
-  }
-  return void 0;
-};
-var staticPropertyName4 = (property) => {
-  if (property.key.type === "Identifier") {
-    return property.key.name;
-  }
-  if (property.key.type === "Literal" && typeof property.key.value === "string") {
-    return property.key.value;
-  }
-  return void 0;
-};
 var destructuringSource = (node) => {
   const parent = node.parent;
   if (parent.type === "VariableDeclarator" && parent.id === node) {
@@ -12321,19 +12962,6 @@ var restrictedGlobalDiagnostic = (node, name) => Diagnostic_exports.make({
   node,
   message: `Global \`${name}\` is not portable across Foldkit server targets. Use a server API available everywhere you deploy or pass the value into the entry.`
 });
-var indexReferences2 = (scopes) => {
-  const references = /* @__PURE__ */ new WeakMap();
-  for (const scope3 of scopes) {
-    for (const reference of scope3.references) {
-      references.set(reference.identifier, reference);
-    }
-  }
-  return references;
-};
-var isUnshadowedGlobalReference = (references, node) => {
-  const reference = references.get(node);
-  return reference !== void 0 && (reference.resolved === null || Array_exports.isArrayEmpty(reference.resolved.defs));
-};
 var noNonportableServerGlobals = Rule_exports.define({
   name: "no-nonportable-server-globals",
   meta: Rule_exports.meta({
@@ -12342,23 +12970,23 @@ var noNonportableServerGlobals = Rule_exports.define({
   }),
   create: function* () {
     const ctx = yield* RuleContext;
-    const references = indexReferences2(ctx.sourceCode.scopeManager.scopes);
+    const references = indexReferences(ctx.sourceCode.scopeManager.scopes);
     return {
       Identifier: (node) => {
         if (node.type !== "Identifier" || !restrictedGlobalNames.has(node.name) || isInsideTypeQuery(node)) {
           return Effect_exports.void;
         }
-        return isUnshadowedGlobalReference(references, node) ? ctx.report(restrictedGlobalDiagnostic(node, node.name)) : Effect_exports.void;
+        return isUnshadowedReference(references, node) ? ctx.report(restrictedGlobalDiagnostic(node, node.name)) : Effect_exports.void;
       },
       MemberExpression: (node) => {
         if (node.type !== "MemberExpression" || node.object.type !== "Identifier" || node.object.name !== "globalThis") {
           return Effect_exports.void;
         }
-        const memberName = staticMemberName(node);
-        if (memberName === void 0 || !restrictedGlobalNames.has(memberName)) {
+        const maybeMemberName = staticMemberName(node);
+        if (Option_exports.isNone(maybeMemberName) || !restrictedGlobalNames.has(maybeMemberName.value)) {
           return Effect_exports.void;
         }
-        return isUnshadowedGlobalReference(references, node.object) ? ctx.report(restrictedGlobalDiagnostic(node, memberName)) : Effect_exports.void;
+        return isUnshadowedReference(references, node.object) ? ctx.report(restrictedGlobalDiagnostic(node, maybeMemberName.value)) : Effect_exports.void;
       },
       ObjectPattern: (node) => {
         if (node.type !== "ObjectPattern") {
@@ -12372,10 +13000,10 @@ var noNonportableServerGlobals = Rule_exports.define({
           if (property.type !== "Property") {
             return [];
           }
-          const name = staticPropertyName4(property);
-          return name !== void 0 && restrictedGlobalNames.has(name) ? [{ name, property }] : [];
+          const maybeName = staticPropertyName(property);
+          return Option_exports.isSome(maybeName) && restrictedGlobalNames.has(maybeName.value) ? [{ name: maybeName.value, property }] : [];
         });
-        return isUnshadowedGlobalReference(references, source) ? Effect_exports.forEach(
+        return isUnshadowedReference(references, source) ? Effect_exports.forEach(
           restrictedProperties,
           ({ name, property }) => ctx.report(restrictedGlobalDiagnostic(property, name)),
           { discard: true }
@@ -12732,6 +13360,139 @@ var preferCallableMessageConstructor = Rule_exports.define({
   }
 });
 
+// src/rules/prefer-effect-module-names.ts
+var EFFECT_MODULE_NAME = /^[A-Z]/;
+var isSemanticConflictAlias = (name, localName) => localName === `Effect${name}`;
+var importedName2 = (specifier) => {
+  if (isIdentifier(specifier.imported)) {
+    return Option_exports.some(specifier.imported.name);
+  }
+  if (isStringLiteral(specifier.imported)) {
+    return Option_exports.some(specifier.imported.value);
+  }
+  return Option_exports.none();
+};
+var importVariable = (ctx, specifier) => {
+  const scopeManager = ctx.sourceCode.scopeManager;
+  if (scopeManager === void 0) {
+    return void 0;
+  }
+  return Array_exports.findFirst(
+    scopeManager.getDeclaredVariables(specifier),
+    (variable) => variable.name === specifier.local.name
+  ).pipe(Option_exports.getOrUndefined);
+};
+var hasUnshadowedReference = (ctx, name) => Array_exports.some(
+  ctx.sourceCode.scopeManager?.scopes ?? [],
+  (scope3) => Array_exports.some(
+    scope3.references,
+    (reference) => reference.identifier.name === name && (reference.resolved === null || Array_exports.isArrayEmpty(reference.resolved.defs))
+  )
+);
+var preservesObservableName = (node) => {
+  const parent = node.parent;
+  if (parent === null) {
+    return true;
+  }
+  if (parent.type === "Property" && parent.shorthand) {
+    return false;
+  }
+  return parent.type !== "ExportSpecifier";
+};
+var hasInterveningBinding = (scope3, importScope, name) => {
+  if (scope3 === importScope) {
+    return false;
+  }
+  if (scope3.set.get(name) !== void 0 || scope3.upper === null) {
+    return true;
+  }
+  return hasInterveningBinding(scope3.upper, importScope, name);
+};
+var referenceCanBeRenamed = (reference, importScope, name) => preservesObservableName(reference.identifier) && !hasInterveningBinding(reference.from, importScope, name);
+var aliasedEffectModule = (specifier) => {
+  if (specifier.type !== "ImportSpecifier" || specifier.importKind === "type") {
+    return Option_exports.none();
+  }
+  return Option_exports.flatMap(
+    importedName2(specifier),
+    (name) => EFFECT_MODULE_NAME.test(name) && specifier.local.name !== name && !isSemanticConflictAlias(name, specifier.local.name) ? Option_exports.some({ specifier, name }) : Option_exports.none()
+  );
+};
+var importsEffectModuleAsAlias = (variable, name) => Array_exports.some(variable.defs, (definition) => {
+  if (definition.type !== "ImportBinding" || definition.node.type !== "ImportSpecifier") {
+    return false;
+  }
+  const declaration = definition.node.parent;
+  if (declaration.type !== "ImportDeclaration" || declaration.source.value !== "effect" || declaration.importKind === "type") {
+    return false;
+  }
+  return Option_exports.match(aliasedEffectModule(definition.node), {
+    onNone: () => false,
+    onSome: (alias) => alias.name === name
+  });
+});
+var hasCompetingRenameTarget = (variable, name) => Array_exports.some(
+  variable.scope.variables,
+  (candidate) => candidate !== variable && importsEffectModuleAsAlias(candidate, name)
+);
+var canRenameBinding = (ctx, variable, name) => variable.scope.set.get(name) === void 0 && !hasUnshadowedReference(ctx, name) && !hasCompetingRenameTarget(variable, name) && Array_exports.every(
+  variable.references,
+  (reference) => referenceCanBeRenamed(reference, variable.scope, name)
+);
+var fixesForAlias = (ctx, { specifier, name }) => {
+  const variable = importVariable(ctx, specifier);
+  if (variable === void 0 || Array_exports.isArrayNonEmpty(ctx.sourceCode.getCommentsInside(specifier)) || !canRenameBinding(ctx, variable, name)) {
+    return [];
+  }
+  return [
+    Diagnostic_exports.replaceText(specifier, name),
+    ...Array_exports.map(
+      variable.references,
+      (reference) => Diagnostic_exports.replaceText(reference.identifier, name)
+    )
+  ];
+};
+var preferEffectModuleNames = Rule_exports.define({
+  name: "prefer-effect-module-names",
+  meta: Rule_exports.meta({
+    type: "suggestion",
+    description: "Use Effect module names without import aliases.",
+    fixable: "code"
+  }),
+  create: function* () {
+    const ctx = yield* RuleContext;
+    return {
+      ImportDeclaration: (node) => {
+        if (node.type !== "ImportDeclaration" || node.source.value !== "effect" || node.importKind === "type") {
+          return Effect_exports.void;
+        }
+        const aliases = Array_exports.flatMap(
+          node.specifiers,
+          (specifier) => Option_exports.match(aliasedEffectModule(specifier), {
+            onNone: () => [],
+            onSome: (alias) => [alias]
+          })
+        );
+        if (Array_exports.isReadonlyArrayEmpty(aliases)) {
+          return Effect_exports.void;
+        }
+        const replacements = Array_exports.map(
+          aliases,
+          ({ specifier, name }) => `\`${name}\` instead of \`${specifier.local.name}\``
+        );
+        const diagnostic = Diagnostic_exports.make({
+          node,
+          message: `Use Effect module names without aliases: ${replacements.join(", ")}. Qualify same-named globals through \`globalThis\`.`
+        });
+        const fixes = Array_exports.flatMap(aliases, (alias) => fixesForAlias(ctx, alias));
+        return ctx.report(
+          Array_exports.isReadonlyArrayEmpty(fixes) ? diagnostic : Diagnostic_exports.withFix(diagnostic, Diagnostic_exports.composeFixes(...fixes))
+        );
+      }
+    };
+  }
+});
+
 // src/rules/require-rel-for-external-link.ts
 var protectiveRelSubstrings = ["noopener", "noreferrer"];
 var isTargetBlankElement = (element) => {
@@ -13117,12 +13878,14 @@ var basePlugin = Plugin_exports.define({
     "no-empty-object-tagged-call": noEmptyObjectTaggedCall,
     "no-hand-rolled-command-struct": noHandRolledCommandStruct,
     "no-hardcoded-route-strings": noHardcodedRouteStrings,
+    "no-impure-call-at-decision-time": noImpureCallAtDecisionTime,
     "no-module-level-mutable-state": noModuleLevelMutableState,
     "no-nonportable-server-globals": noNonportableServerGlobals,
     "no-noop-message": noNoopMessage,
     "no-raw-dom-event-attributes": noRawDomEventAttributes,
     "no-spread-in-evo": noSpreadInEvo,
     "prefer-callable-message-constructor": preferCallableMessageConstructor,
+    "prefer-effect-module-names": preferEffectModuleNames,
     "require-rel-for-external-link": requireRelForExternalLink,
     "selection-submodel-factory-at-module-scope": selectionSubmodelFactoryAtModuleScope,
     "wrap-child-output-in-got-message": wrapChildOutputInGotMessage
@@ -13139,22 +13902,38 @@ var serverFilePatterns = [
   "**/entry.server.tsx",
   "**/server/**/*.ts",
   "**/server/**/*.tsx",
-  "**/prerender.ts"
+  "**/prerender.ts",
+  "**/prerender.tsx"
+];
+var entryFilePatterns = [
+  "**/entry.ts",
+  "**/entry.tsx",
+  "**/entry.client.ts",
+  "**/entry.client.tsx",
+  "**/entry.server.ts",
+  "**/entry.server.tsx"
 ];
+var decisionTimeRuleId = "foldkit/no-impure-call-at-decision-time";
 var serverOverride = {
   files: serverFilePatterns,
   excludeFiles: testFilePatterns,
   rules: {
-    "foldkit/no-nonportable-server-globals": "error"
+    "foldkit/no-nonportable-server-globals": "error",
+    [decisionTimeRuleId]: "off"
+  }
+};
+var entryOverride = {
+  files: entryFilePatterns,
+  excludeFiles: testFilePatterns,
+  rules: {
+    [decisionTimeRuleId]: "off"
   }
 };
+var rulesApplicableToTests = /* @__PURE__ */ new Set(["foldkit/prefer-effect-module-names"]);
 var testOverride = (config) => ({
   files: testFilePatterns,
   rules: Object.fromEntries(
-    Object.keys(config.rules).map((id) => [
-      id,
-      "off"
-    ])
+    Object.keys(config.rules).filter((id) => !rulesApplicableToTests.has(id)).map((id) => [id, "off"])
   )
 });
 var withOverrides = (config) => ({
@@ -13163,7 +13942,7 @@ var withOverrides = (config) => ({
     ...config.rules,
     "foldkit/no-nonportable-server-globals": "off"
   },
-  overrides: [serverOverride, testOverride(config)]
+  overrides: [serverOverride, entryOverride, testOverride(config)]
 });
 var index_default = {
   ...basePlugin,