@foldkit/oxlint-plugin 0.11.0-canary.00c836c7927f → 0.11.0-canary.21d56b2de3cd

package/all.json

@@ -24,6 +24,7 @@
     "foldkit/no-empty-object-tagged-call": "error",
     "foldkit/no-hand-rolled-command-struct": "error",
     "foldkit/no-hardcoded-route-strings": "error",
+    "foldkit/no-impure-call-at-decision-time": "error",
     "foldkit/no-module-level-mutable-state": "error",
     "foldkit/no-nonportable-server-globals": "off",
     "foldkit/no-noop-message": "error",
@@ -41,7 +42,8 @@
         "**/entry.server.tsx",
         "**/server/**/*.ts",
         "**/server/**/*.tsx",
-        "**/prerender.ts"
+        "**/prerender.ts",
+        "**/prerender.tsx"
       ],
       "excludeFiles": [
         "**/*.test.ts",
@@ -50,7 +52,27 @@
         "**/*.spec.tsx"
       ],
       "rules": {
-        "foldkit/no-nonportable-server-globals": "error"
+        "foldkit/no-nonportable-server-globals": "error",
+        "foldkit/no-impure-call-at-decision-time": "off"
+      }
+    },
+    {
+      "files": [
+        "**/entry.ts",
+        "**/entry.tsx",
+        "**/entry.client.ts",
+        "**/entry.client.tsx",
+        "**/entry.server.ts",
+        "**/entry.server.tsx"
+      ],
+      "excludeFiles": [
+        "**/*.test.ts",
+        "**/*.test.tsx",
+        "**/*.spec.ts",
+        "**/*.spec.tsx"
+      ],
+      "rules": {
+        "foldkit/no-impure-call-at-decision-time": "off"
       }
     },
     {
@@ -79,6 +101,7 @@
         "foldkit/no-empty-object-tagged-call": "off",
         "foldkit/no-hand-rolled-command-struct": "off",
         "foldkit/no-hardcoded-route-strings": "off",
+        "foldkit/no-impure-call-at-decision-time": "off",
         "foldkit/no-module-level-mutable-state": "off",
         "foldkit/no-nonportable-server-globals": "off",
         "foldkit/no-noop-message": "off",

package/dist/guards.d.ts

@@ -1,19 +1,16 @@
 import { Option } from 'effect';
-import { type ESTree } from 'effect-oxlint';
+import { type ESTree, type OxlintScope, type Reference } from 'effect-oxlint';
 export declare const isIdentifier: (node: unknown, name?: string) => node is Readonly<{
     type: 'Identifier';
     name: string;
 }>;
+export declare const isIdentifierReference: (node: unknown) => node is ESTree.IdentifierReference;
 export declare const isStringLiteral: (node: unknown) => node is ESTree.StringLiteral;
 export declare const isTemplateLiteral: (node: unknown) => node is ESTree.TemplateLiteral;
 export declare const isCallExpression: (node: unknown) => node is ESTree.CallExpression;
-export declare const isMemberExpression: (node: unknown) => node is Readonly<{
-    type: 'MemberExpression';
-    object: unknown;
-    property: unknown;
-    computed?: boolean;
-}>;
+export declare const isMemberExpression: (node: unknown) => node is ESTree.MemberExpression;
 export declare const isObjectExpression: (node: unknown) => node is ESTree.ObjectExpression;
+export declare const isObjectProperty: (node: unknown) => node is ESTree.ObjectProperty;
 export declare const isArrayExpression: (node: unknown) => node is Readonly<{
     type: 'ArrayExpression';
     elements: ReadonlyArray<unknown>;
@@ -22,6 +19,13 @@ export declare const isSpreadElement: (node: unknown) => boolean;
 export declare const helperCalleeName: (callee: unknown) => Option.Option<string>;
 export declare const calleeMatchesHelperName: (callee: unknown, helperName: string) => boolean;
 export declare const staticStringValue: (node: unknown) => Option.Option<string>;
+export declare const staticMemberName: (node: ESTree.MemberExpression) => Option.Option<string>;
+export declare const staticPropertyName: (property: Readonly<{
+    computed?: boolean;
+    key: ESTree.PropertyKey;
+}>) => Option.Option<string>;
+export declare const indexReferences: (scopes: ReadonlyArray<OxlintScope>) => WeakMap<ESTree.Node, Reference>;
+export declare const isUnshadowedReference: (references: WeakMap<ESTree.Node, Reference> | undefined, node: ESTree.Node) => boolean;
 export declare const isVariableDeclarator: (node: unknown) => node is ESTree.VariableDeclarator;
 export declare const isVariableDeclaration: (node: unknown) => node is ESTree.VariableDeclaration;
 export declare const isProgram: (node: unknown) => node is ESTree.Program;

package/dist/guards.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"guards.d.ts","sourceRoot":"","sources":["../src/guards.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,MAAM,EAAE,MAAM,QAAQ,CAAA;AACtC,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,eAAe,CAAA;AAE3C,eAAO,MAAM,YAAY,SACjB,OAAO,SACN,MAAM,KACZ,IAAI,IAAI,QAAQ,CAAC;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAOZ,CAAA;AAE5C,eAAO,MAAM,eAAe,SAAU,OAAO,KAAG,IAAI,IAAI,MAAM,CAAC,aAM/B,CAAA;AAEhC,eAAO,MAAM,iBAAiB,SACtB,OAAO,KACZ,IAAI,IAAI,MAAM,CAAC,eAIe,CAAA;AAEjC,eAAO,MAAM,gBAAgB,SACrB,OAAO,KACZ,IAAI,IAAI,MAAM,CAAC,cAIc,CAAA;AAEhC,eAAO,MAAM,kBAAkB,SACvB,OAAO,KACZ,IAAI,IAAI,QAAQ,CAAC;IAClB,IAAI,EAAE,kBAAkB,CAAA;IACxB,MAAM,EAAE,OAAO,CAAA;IACf,QAAQ,EAAE,OAAO,CAAA;IACjB,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB,CAIiC,CAAA;AAElC,eAAO,MAAM,kBAAkB,SACvB,OAAO,KACZ,IAAI,IAAI,MAAM,CAAC,gBAIgB,CAAA;AAElC,eAAO,MAAM,iBAAiB,SACtB,OAAO,KACZ,IAAI,IAAI,QAAQ,CAAC;IAClB,IAAI,EAAE,iBAAiB,CAAA;IACvB,QAAQ,EAAE,aAAa,CAAC,OAAO,CAAC,CAAA;CACjC,CAIgC,CAAA;AAEjC,eAAO,MAAM,eAAe,SAAU,OAAO,KAAG,OAIjB,CAAA;AAE/B,eAAO,MAAM,gBAAgB,WAAY,OAAO,KAAG,MAAM,CAAC,MAAM,CAAC,MAAM,CAYtE,CAAA;AAED,eAAO,MAAM,uBAAuB,WAC1B,OAAO,cACH,MAAM,KACjB,OACmE,CAAA;AAEtE,eAAO,MAAM,iBAAiB,SAAU,OAAO,KAAG,MAAM,CAAC,MAAM,CAAC,MAAM,CAUrE,CAAA;AAED,eAAO,MAAM,oBAAoB,SACzB,OAAO,KACZ,IAAI,IAAI,MAAM,CAAC,kBAIkB,CAAA;AAEpC,eAAO,MAAM,qBAAqB,SAC1B,OAAO,KACZ,IAAI,IAAI,MAAM,CAAC,mBAImB,CAAA;AAErC,eAAO,MAAM,SAAS,SAAU,OAAO,KAAG,IAAI,IAAI,MAAM,CAAC,OAIhC,CAAA;AAEzB,eAAO,MAAM,mBAAmB,SACxB,MAAM,CAAC,cAAc,KAC1B,MAAM,CAAC,aAAa,GAAG,SAGzB,CAAA"}
+{"version":3,"file":"guards.d.ts","sourceRoot":"","sources":["../src/guards.ts"],"names":[],"mappings":"AAAA,OAAO,EAAS,MAAM,EAAE,MAAM,QAAQ,CAAA;AACtC,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,WAAW,EAAE,KAAK,SAAS,EAAE,MAAM,eAAe,CAAA;AAE7E,eAAO,MAAM,YAAY,SACjB,OAAO,SACN,MAAM,KACZ,IAAI,IAAI,QAAQ,CAAC;IAAE,IAAI,EAAE,YAAY,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAOZ,CAAA;AAE5C,eAAO,MAAM,qBAAqB,SAC1B,OAAO,KACZ,IAAI,IAAI,MAAM,CAAC,mBAAyC,CAAA;AAE3D,eAAO,MAAM,eAAe,SAAU,OAAO,KAAG,IAAI,IAAI,MAAM,CAAC,aAM/B,CAAA;AAEhC,eAAO,MAAM,iBAAiB,SACtB,OAAO,KACZ,IAAI,IAAI,MAAM,CAAC,eAIe,CAAA;AAEjC,eAAO,MAAM,gBAAgB,SACrB,OAAO,KACZ,IAAI,IAAI,MAAM,CAAC,cAIc,CAAA;AAEhC,eAAO,MAAM,kBAAkB,SACvB,OAAO,KACZ,IAAI,IAAI,MAAM,CAAC,gBAIgB,CAAA;AAElC,eAAO,MAAM,kBAAkB,SACvB,OAAO,KACZ,IAAI,IAAI,MAAM,CAAC,gBAIgB,CAAA;AAElC,eAAO,MAAM,gBAAgB,SACrB,OAAO,KACZ,IAAI,IAAI,MAAM,CAAC,cAIQ,CAAA;AAE1B,eAAO,MAAM,iBAAiB,SACtB,OAAO,KACZ,IAAI,IAAI,QAAQ,CAAC;IAClB,IAAI,EAAE,iBAAiB,CAAA;IACvB,QAAQ,EAAE,aAAa,CAAC,OAAO,CAAC,CAAA;CACjC,CAIgC,CAAA;AAEjC,eAAO,MAAM,eAAe,SAAU,OAAO,KAAG,OAIjB,CAAA;AAE/B,eAAO,MAAM,gBAAgB,WAAY,OAAO,KAAG,MAAM,CAAC,MAAM,CAAC,MAAM,CAYtE,CAAA;AAED,eAAO,MAAM,uBAAuB,WAC1B,OAAO,cACH,MAAM,KACjB,OACmE,CAAA;AAEtE,eAAO,MAAM,iBAAiB,SAAU,OAAO,KAAG,MAAM,CAAC,MAAM,CAAC,MAAM,CAUrE,CAAA;AAED,eAAO,MAAM,gBAAgB,SACrB,MAAM,CAAC,gBAAgB,KAC5B,MAAM,CAAC,MAAM,CAAC,MAAM,CAKtB,CAAA;AAED,eAAO,MAAM,kBAAkB,aACnB,QAAQ,CAAC;IACjB,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,GAAG,EAAE,MAAM,CAAC,WAAW,CAAA;CACxB,CAAC,KACD,MAAM,CAAC,MAAM,CAAC,MAAM,CAKtB,CAAA;AAED,eAAO,MAAM,eAAe,WAClB,aAAa,CAAC,WAAW,CAAC,KACjC,OAAO,CAAC,MAAM,CAAC,IAAI,EAAE,SAAS,CAShC,CAAA;AAED,eAAO,MAAM,qBAAqB,eACpB,OAAO,CAAC,MAAM,CAAC,IAAI,EAAE,SAAS,CAAC,GAAG,SAAS,QACjD,MAAM,CAAC,IAAI,KAChB,OAUF,CAAA;AAED,eAAO,MAAM,oBAAoB,SACzB,OAAO,KACZ,IAAI,IAAI,MAAM,CAAC,kBAIkB,CAAA;AAEpC,eAAO,MAAM,qBAAqB,SAC1B,OAAO,KACZ,IAAI,IAAI,MAAM,CAAC,mBAImB,CAAA;AAErC,eAAO,MAAM,SAAS,SAAU,OAAO,KAAG,IAAI,IAAI,MAAM,CAAC,OAIhC,CAAA;AAEzB,eAAO,MAAM,mBAAmB,SACxB,MAAM,CAAC,cAAc,KAC1B,MAAM,CAAC,aAAa,GAAG,SAGzB,CAAA"}

package/dist/index.d.ts

@@ -30,6 +30,7 @@ declare const _default: {
         readonly 'no-empty-object-tagged-call': import("effect-oxlint").CreateRule;
         readonly 'no-hand-rolled-command-struct': import("effect-oxlint").CreateRule;
         readonly 'no-hardcoded-route-strings': import("effect-oxlint").CreateRule;
+        readonly 'no-impure-call-at-decision-time': import("effect-oxlint").CreateRule;
         readonly 'no-module-level-mutable-state': import("effect-oxlint").CreateRule;
         readonly 'no-nonportable-server-globals': import("effect-oxlint").CreateRule;
         readonly 'no-noop-message': import("effect-oxlint").CreateRule;

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAA;AAiEtC,KAAK,QAAQ,GAAG,QAAQ,CAAC;IACvB,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;IACpB,YAAY,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;IAC5B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,YAAY,CAAC,CAAA;CAC3C,CAAC,CAAA;AAEF,KAAK,gBAAgB,GAAG,MAAM,CAAC,YAAY,GAAG;IAC5C,SAAS,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAA;CAC3B,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAoDG,WAAW;QACX,GAAG"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,eAAe,CAAA;AAmEtC,KAAK,QAAQ,GAAG,QAAQ,CAAC;IACvB,KAAK,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;IACpB,YAAY,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;IAC5B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,YAAY,CAAC,CAAA;CAC3C,CAAC,CAAA;AAEF,KAAK,gBAAgB,GAAG,MAAM,CAAC,YAAY,GAAG;IAC5C,SAAS,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAA;CAC3B,CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;QAyEG,WAAW;QACX,GAAG"}

package/dist/index.js

@@ -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();
       });
     };
@@ -10387,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) => {
@@ -10416,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";
@@ -10544,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;
@@ -10580,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
       }
     ];
@@ -11828,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)) {
@@ -11876,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)
@@ -11996,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) {
@@ -12037,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) => {
@@ -12082,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
           )
         );
@@ -12097,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({
@@ -12260,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) => {
@@ -12329,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) {
@@ -12365,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({
@@ -12386,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") {
@@ -12416,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 }
@@ -13161,6 +13745,7 @@ 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,
@@ -13183,13 +13768,31 @@ 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 testOverride = (config) => ({
@@ -13207,7 +13810,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,

package/dist/message.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"message.d.ts","sourceRoot":"","sources":["../src/message.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,eAAe,CAAA;AAM3C,MAAM,MAAM,WAAW,GAAG,QAAQ,CAAC;IACjC,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,MAAM,CAAC,IAAI,CAAA;IACrB,MAAM,EAAE,MAAM,CAAC,gBAAgB,CAAA;CAChC,CAAC,CAAA;AAoBF,eAAO,MAAM,iCAAiC,aAClC,GAAG,CAAC,MAAM,CAAC,QACf,MAAM,CAAC,IAAI,KAChB,IA0BF,CAAA;AAED,eAAO,MAAM,YAAY,SACjB,MAAM,CAAC,cAAc,YACjB,WAAW,CAAC,MAAM,CAAC,KAC5B,aAAa,CAAC,WAAW,CA4B3B,CAAA;AAED,eAAO,MAAM,yBAAyB,WAC5B,MAAM,CAAC,gBAAgB,KAC9B,OAMA,CAAA"}
+{"version":3,"file":"message.d.ts","sourceRoot":"","sources":["../src/message.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,KAAK,MAAM,EAAE,MAAM,eAAe,CAAA;AAW3C,MAAM,MAAM,WAAW,GAAG,QAAQ,CAAC;IACjC,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,MAAM,CAAC,IAAI,CAAA;IACrB,MAAM,EAAE,MAAM,CAAC,gBAAgB,CAAA;CAChC,CAAC,CAAA;AAEF,eAAO,MAAM,iCAAiC,aAClC,GAAG,CAAC,MAAM,CAAC,QACf,MAAM,CAAC,IAAI,KAChB,IA0BF,CAAA;AAED,eAAO,MAAM,YAAY,SACjB,MAAM,CAAC,cAAc,YACjB,WAAW,CAAC,MAAM,CAAC,KAC5B,aAAa,CAAC,WAAW,CA4B3B,CAAA;AAED,eAAO,MAAM,yBAAyB,WAC5B,MAAM,CAAC,gBAAgB,KAC9B,OAMA,CAAA"}

package/dist/rules/no-empty-commands-array.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"no-empty-commands-array.d.ts","sourceRoot":"","sources":["../../src/rules/no-empty-commands-array.ts"],"names":[],"mappings":"AA+DA;;;2EAG2E;AAC3E,eAAO,MAAM,oBAAoB,oCAyE/B,CAAA"}
+{"version":3,"file":"no-empty-commands-array.d.ts","sourceRoot":"","sources":["../../src/rules/no-empty-commands-array.ts"],"names":[],"mappings":"AAgDA;;;2EAG2E;AAC3E,eAAO,MAAM,oBAAoB,oCAyE/B,CAAA"}

package/dist/rules/no-empty-to-parent-out-message.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"no-empty-to-parent-out-message.d.ts","sourceRoot":"","sources":["../../src/rules/no-empty-to-parent-out-message.ts"],"names":[],"mappings":"AAsJA;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB,oCAgFpC,CAAA"}
+{"version":3,"file":"no-empty-to-parent-out-message.d.ts","sourceRoot":"","sources":["../../src/rules/no-empty-to-parent-out-message.ts"],"names":[],"mappings":"AAgHA;;;;;GAKG;AACH,eAAO,MAAM,yBAAyB,oCAgFpC,CAAA"}

package/dist/rules/no-impure-call-at-decision-time.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Flags direct calls to known nondeterministic globals unless they appear in a
+ * recognized deferred Effect, Stream, Command, Mount, Subscription, or
+ * ManagedResource callback.
+ */
+export declare const noImpureCallAtDecisionTime: import("effect-oxlint").CreateRule;
+//# sourceMappingURL=no-impure-call-at-decision-time.d.ts.map

package/dist/rules/no-impure-call-at-decision-time.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"no-impure-call-at-decision-time.d.ts","sourceRoot":"","sources":["../../src/rules/no-impure-call-at-decision-time.ts"],"names":[],"mappings":"AA80BA;;;;GAIG;AACH,eAAO,MAAM,0BAA0B,oCAyCrC,CAAA"}

package/dist/rules/no-nonportable-server-globals.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"no-nonportable-server-globals.d.ts","sourceRoot":"","sources":["../../src/rules/no-nonportable-server-globals.ts"],"names":[],"mappings":"AAuIA;;GAEG;AACH,eAAO,MAAM,0BAA0B,oCAsErC,CAAA"}
+{"version":3,"file":"no-nonportable-server-globals.d.ts","sourceRoot":"","sources":["../../src/rules/no-nonportable-server-globals.ts"],"names":[],"mappings":"AA+EA;;GAEG;AACH,eAAO,MAAM,0BAA0B,oCAuErC,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@foldkit/oxlint-plugin",
-  "version": "0.11.0-canary.00c836c7927f",
+  "version": "0.11.0-canary.21d56b2de3cd",
   "description": "Oxlint rules for Foldkit applications",
   "type": "module",
   "main": "./dist/index.js",

package/recommended.json

@@ -24,6 +24,7 @@
     "foldkit/no-empty-object-tagged-call": "error",
     "foldkit/no-hand-rolled-command-struct": "error",
     "foldkit/no-hardcoded-route-strings": "error",
+    "foldkit/no-impure-call-at-decision-time": "error",
     "foldkit/no-module-level-mutable-state": "error",
     "foldkit/no-nonportable-server-globals": "off",
     "foldkit/no-noop-message": "error",
@@ -41,7 +42,8 @@
         "**/entry.server.tsx",
         "**/server/**/*.ts",
         "**/server/**/*.tsx",
-        "**/prerender.ts"
+        "**/prerender.ts",
+        "**/prerender.tsx"
       ],
       "excludeFiles": [
         "**/*.test.ts",
@@ -50,7 +52,27 @@
         "**/*.spec.tsx"
       ],
       "rules": {
-        "foldkit/no-nonportable-server-globals": "error"
+        "foldkit/no-nonportable-server-globals": "error",
+        "foldkit/no-impure-call-at-decision-time": "off"
+      }
+    },
+    {
+      "files": [
+        "**/entry.ts",
+        "**/entry.tsx",
+        "**/entry.client.ts",
+        "**/entry.client.tsx",
+        "**/entry.server.ts",
+        "**/entry.server.tsx"
+      ],
+      "excludeFiles": [
+        "**/*.test.ts",
+        "**/*.test.tsx",
+        "**/*.spec.ts",
+        "**/*.spec.tsx"
+      ],
+      "rules": {
+        "foldkit/no-impure-call-at-decision-time": "off"
       }
     },
     {
@@ -79,6 +101,7 @@
         "foldkit/no-empty-object-tagged-call": "off",
         "foldkit/no-hand-rolled-command-struct": "off",
         "foldkit/no-hardcoded-route-strings": "off",
+        "foldkit/no-impure-call-at-decision-time": "off",
         "foldkit/no-module-level-mutable-state": "off",
         "foldkit/no-nonportable-server-globals": "off",
         "foldkit/no-noop-message": "off",