@foldkit/oxlint-plugin 0.11.0 → 0.12.0

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) => {
@@ -10403,6 +10405,31 @@ var helperCalleeName = (callee) => {
   }
   return Option_exports.none();
 };
+var isTransparentExpression = (node) => typeof node === "object" && node !== null && "type" in node && (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 isTSQualifiedName = (node) => typeof node === "object" && node !== null && "type" in node && node.type === "TSQualifiedName";
+var staticMemberPath = (node) => {
+  const expression = innermostExpression(node);
+  if (isIdentifierReference(expression)) {
+    return Option_exports.some({ root: expression, members: [] });
+  }
+  if (isTSQualifiedName(expression)) {
+    return Option_exports.map(staticMemberPath(expression.left), (path) => ({
+      root: path.root,
+      members: [...path.members, expression.right.name]
+    }));
+  }
+  if (!isMemberExpression(expression)) {
+    return Option_exports.none();
+  }
+  return Option_exports.flatMap(
+    staticMemberPath(expression.object),
+    (path) => Option_exports.map(staticMemberName(expression), (member) => ({
+      root: path.root,
+      members: [...path.members, member]
+    }))
+  );
+};
 var calleeMatchesHelperName = (callee, helperName) => Option_exports.exists(helperCalleeName(callee), (name) => name === helperName);
 var staticStringValue = (node) => {
   if (isStringLiteral(node)) {
@@ -10416,6 +10443,152 @@ 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 resolvedVariable = (references, node) => Option_exports.flatMap(
+  Option_exports.fromNullishOr(references.get(node)),
+  (reference) => Option_exports.fromNullishOr(reference.resolved)
+);
+var importedName = (specifier) => specifier.imported.type === "Identifier" ? specifier.imported.name : specifier.imported.value;
+var resolveImportedPath = (references, node) => Option_exports.gen(function* () {
+  const path = yield* staticMemberPath(node);
+  const variable = yield* resolvedVariable(references, path.root);
+  const definition = yield* Array_exports.findFirst(
+    variable.defs,
+    (definition2) => definition2.type === "ImportBinding"
+  );
+  if (definition.parent?.type !== "ImportDeclaration") {
+    return yield* Option_exports.none();
+  }
+  const localMembers = [path.root.name, ...path.members];
+  if (definition.node.type === "ImportNamespaceSpecifier") {
+    return {
+      source: definition.parent.source.value,
+      members: path.members,
+      localMembers
+    };
+  }
+  if (definition.node.type !== "ImportSpecifier") {
+    return yield* Option_exports.none();
+  }
+  return {
+    source: definition.parent.source.value,
+    members: [importedName(definition.node), ...path.members],
+    localMembers
+  };
+});
+var foldkitNamespaceBySource = {
+  "foldkit/command": "Command",
+  "foldkit/html": "Html",
+  "foldkit/managedResource": "ManagedResource",
+  "foldkit/message": "Message",
+  "foldkit/mount": "Mount",
+  "foldkit/navigation": "Navigation",
+  "foldkit/route": "Route",
+  "foldkit/runtime": "Runtime",
+  "foldkit/schema": "Schema",
+  "foldkit/struct": "Struct",
+  "foldkit/submodel": "Submodel",
+  "foldkit/subscription": "Subscription"
+};
+var resolveFoldkitApiPath = (references, node) => Option_exports.flatMap(resolveImportedPath(references, node), (path) => {
+  if (path.source === "foldkit") {
+    return Option_exports.some(path.members);
+  }
+  const namespace = foldkitNamespaceBySource[path.source];
+  return namespace === void 0 ? Option_exports.none() : Option_exports.some([namespace, ...path.members]);
+});
+var isTypeAnnotatedIdentifier = (node) => isIdentifier(node);
+var isFunctionWithParameters = (node) => typeof node === "object" && node !== null && "type" in node && (node.type === "ArrowFunctionExpression" || node.type === "FunctionDeclaration" || node.type === "FunctionExpression");
+var isFoldkitDefineViewCallback = (references, functionNode) => {
+  const parent = functionNode.parent;
+  if (!isCallExpression(parent) || !parent.arguments.includes(functionNode)) {
+    return false;
+  }
+  return Option_exports.exists(
+    resolveFoldkitApiPath(references, parent.callee),
+    (path) => {
+      const [namespace, helperName, extraMember] = path;
+      return namespace === "Submodel" && helperName === "defineView" && extraMember === void 0;
+    }
+  );
+};
+var hasHtmlBuilderTypeAnnotation = (references, identifier2) => {
+  const typeAnnotation = identifier2.typeAnnotation?.typeAnnotation;
+  if (typeAnnotation?.type !== "TSTypeReference") {
+    return false;
+  }
+  return Option_exports.exists(
+    resolveFoldkitApiPath(references, typeAnnotation.typeName),
+    (path) => {
+      const [namespace, typeName, extraMember] = path;
+      return namespace === "Html" && typeName === "HtmlBuilder" && extraMember === void 0;
+    }
+  );
+};
+var isHtmlBuilderParameter = (references, root) => Option_exports.exists(
+  resolvedVariable(references, root),
+  (variable) => variable.defs.some((definition) => {
+    if (definition.type !== "Parameter" || !isTypeAnnotatedIdentifier(definition.name)) {
+      return false;
+    }
+    if (hasHtmlBuilderTypeAnnotation(references, definition.name)) {
+      return true;
+    }
+    if (!isFunctionWithParameters(definition.node)) {
+      return false;
+    }
+    return Option_exports.exists(
+      Array_exports.last(definition.node.params),
+      (parameter) => parameter === definition.name
+    ) && isFoldkitDefineViewCallback(references, definition.node);
+  })
+);
+var isFoldkitHtmlBuilderMember = (callee, memberName, references) => {
+  if (references === void 0) {
+    return calleeMatchesHelperName(callee, memberName);
+  }
+  const isFoldkitInertHtmlMember = Option_exports.exists(
+    resolveFoldkitApiPath(references, callee),
+    (path) => {
+      const [namespace, builderName, importedMember, extraImportedMember] = path;
+      return namespace === "Html" && builderName === "inertHtml" && importedMember === memberName && extraImportedMember === void 0;
+    }
+  );
+  if (isFoldkitInertHtmlMember) {
+    return true;
+  }
+  return Option_exports.exists(staticMemberPath(callee), (path) => {
+    const [member, extraMember] = path.members;
+    return member === memberName && extraMember === void 0 && isHtmlBuilderParameter(references, path.root);
+  });
+};
+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";
@@ -10425,14 +10598,23 @@ var firstStringArgument = (node) => {
 };
 
 // src/rules/command-binding-matches-name.ts
-var innerCommandDefineCall = (node) => {
+var isCommandDefineCall = (node, references) => {
+  if (references === void 0) {
+    return AST_exports.isCallOf(node, "Command", "define");
+  }
+  return Option_exports.exists(resolveFoldkitApiPath(references, node.callee), (path) => {
+    const [namespace, methodName, extraMember] = path;
+    return namespace === "Command" && methodName === "define" && extraMember === void 0;
+  });
+};
+var innerCommandDefineCall = (node, references) => {
   if (!isCallExpression(node)) return void 0;
-  if (AST_exports.isCallOf(node, "Command", "define")) {
+  if (isCommandDefineCall(node, references)) {
     return node;
   }
   const callee = node.callee;
   if (!isCallExpression(callee)) return void 0;
-  if (!AST_exports.isCallOf(callee, "Command", "define")) return void 0;
+  if (!isCommandDefineCall(callee, references)) return void 0;
   return callee;
 };
 var commandBindingMatchesName = Rule_exports.define({
@@ -10443,12 +10625,14 @@ var commandBindingMatchesName = Rule_exports.define({
   }),
   create: function* () {
     const ctx = yield* RuleContext;
+    const scopes = ctx.sourceCode.scopeManager?.scopes;
+    const references = scopes === void 0 ? void 0 : indexReferences(scopes);
     return {
       VariableDeclarator: (node) => {
         if (!isVariableDeclarator(node)) return Effect_exports.void;
         const init2 = node.init;
         if (init2 === null || init2 === void 0) return Effect_exports.void;
-        const innerCall = innerCommandDefineCall(init2);
+        const innerCall = innerCommandDefineCall(init2, references);
         if (innerCall === void 0) return Effect_exports.void;
         const nameArgument = firstStringArgument(innerCall);
         if (nameArgument === void 0 || !isIdentifier(node.id) || node.id.name === nameArgument.value) {
@@ -10477,21 +10661,30 @@ var nearestVariableDeclarator = (node) => {
   }
   return "parent" in node ? nearestVariableDeclarator(node.parent) : Option_exports.none();
 };
-var headCommandDefineCall = (node) => {
+var isCommandDefineCall2 = (node, references) => {
+  if (references === void 0) {
+    return AST_exports.isCallOf(node, "Command", "define");
+  }
+  return Option_exports.exists(resolveFoldkitApiPath(references, node.callee), (path) => {
+    const [namespace, methodName, extraMember] = path;
+    return namespace === "Command" && methodName === "define" && extraMember === void 0;
+  });
+};
+var headCommandDefineCall = (node, references) => {
   if (!isCallExpression(node)) {
     return Option_exports.none();
   }
-  if (AST_exports.isCallOf(node, "Command", "define")) {
+  if (isCommandDefineCall2(node, references)) {
     return Option_exports.some(node);
   }
-  return headCommandDefineCall(node.callee);
+  return headCommandDefineCall(node.callee, references);
 };
 var missingLiteralNameMessage = "Command.define needs a literal string name as its first argument. The name is the Command's identity and cannot be computed.";
 var nonPascalCaseMessage = (name) => `Command.define('${name}', ...) must use a PascalCase name, like FetchWeather or FocusInput.`;
 var notAssignedMessage = (name) => `Command.define('${name}', ...) must be assigned to a PascalCase const, never inlined in a pipe or expression. Write const ${name} = Command.define('${name}', ...).`;
 var mismatchedConstMessage = (name, actualName) => `Command.define('${name}', ...) should be assigned to a const named ${name}, not ${actualName}. The const name mirrors the Command identity.`;
 var notConstMessage = (name) => `Command.define('${name}', ...) must be assigned to a const, not let or var. Write const ${name} = Command.define('${name}', ...).`;
-var diagnosticMessage = (node) => {
+var diagnosticMessage = (node, references) => {
   const [firstArgument] = node.arguments;
   if (!isStringLiteral(firstArgument)) {
     return Option_exports.some(missingLiteralNameMessage);
@@ -10504,7 +10697,7 @@ var diagnosticMessage = (node) => {
     onNone: () => Option_exports.some(notAssignedMessage(name)),
     onSome: (declarator) => {
       const headsInitializer = Option_exports.exists(
-        headCommandDefineCall(declarator.init),
+        headCommandDefineCall(declarator.init, references),
         (call) => call === node
       );
       if (!headsInitializer) {
@@ -10528,12 +10721,14 @@ var commandDefinePascalConst = Rule_exports.define({
   }),
   create: function* () {
     const ctx = yield* RuleContext;
+    const scopes = ctx.sourceCode.scopeManager?.scopes;
+    const references = scopes === void 0 ? void 0 : indexReferences(scopes);
     return {
       CallExpression: (node) => {
-        if (!isCallExpression(node) || !AST_exports.isCallOf(node, "Command", "define")) {
+        if (!isCallExpression(node) || !isCommandDefineCall2(node, references)) {
           return Effect_exports.void;
         }
-        return Option_exports.match(diagnosticMessage(node), {
+        return Option_exports.match(diagnosticMessage(node, references), {
           onNone: () => Effect_exports.void,
           onSome: (message) => ctx.report(Diagnostic_exports.make({ node, message }))
         });
@@ -10544,18 +10739,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;
@@ -10571,8 +10754,17 @@ var recordFoldkitMessageUnionBindings = (bindings, node) => {
     }
   }
 };
-var messageCases = (node, bindings) => {
-  if (!isIdentifier(node.callee) || !bindings.has(node.callee.name)) {
+var isFoldkitMessageUnionCall = (node, bindings, references) => {
+  if (references === void 0) {
+    return isIdentifier(node.callee) && bindings.has(node.callee.name);
+  }
+  return Option_exports.exists(resolveFoldkitApiPath(references, node.callee), (path) => {
+    const [namespace, helperName, extraMember] = path;
+    return namespace === "Message" && helperName === "defineMessageUnion" && extraMember === void 0;
+  });
+};
+var messageCases = (node, bindings, references) => {
+  if (!isFoldkitMessageUnionCall(node, bindings, references)) {
     return [];
   }
   const [casesByTag] = node.arguments;
@@ -10580,14 +10772,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
       }
     ];
@@ -10596,6 +10791,38 @@ var messageCases = (node, bindings) => {
 var hasMessagePayloadProperty = (fields) => fields.properties.some(
   (property) => property.type === "Property" && (isIdentifier(property.key, "message") || isStringLiteral(property.key) && property.key.value === "message")
 );
+var containsImportedMessageReference = (node, references, visited) => {
+  if (typeof node !== "object" || node === null || visited.has(node)) {
+    return false;
+  }
+  visited.add(node);
+  if (Option_exports.exists(resolveImportedPath(references, node), (path) => {
+    const [messageName] = path.members.slice(-1);
+    return messageName === "Message";
+  })) {
+    return true;
+  }
+  return Object.entries(node).some(
+    ([key, value]) => key !== "parent" && (Array.isArray(value) ? value.some(
+      (element) => containsImportedMessageReference(element, references, visited)
+    ) : containsImportedMessageReference(value, references, visited))
+  );
+};
+var hasSubmodelMessagePayload = (fields, references) => {
+  if (references === void 0) {
+    return hasMessagePayloadProperty(fields);
+  }
+  return fields.properties.some((property) => {
+    if (property.type !== "Property" || !(isIdentifier(property.key, "message") || isStringLiteral(property.key) && property.key.value === "message")) {
+      return false;
+    }
+    return containsImportedMessageReference(
+      property.value,
+      references,
+      /* @__PURE__ */ new WeakSet()
+    );
+  });
+};
 
 // src/rules/got-prefix-requires-submodel-payload.ts
 var gotPrefixRequiresSubmodelPayload = Rule_exports.define({
@@ -10606,6 +10833,8 @@ var gotPrefixRequiresSubmodelPayload = Rule_exports.define({
   }),
   create: function* () {
     const ctx = yield* RuleContext;
+    const scopes = ctx.sourceCode.scopeManager?.scopes;
+    const references = scopes === void 0 ? void 0 : indexReferences(scopes);
     const messageUnionBindings = /* @__PURE__ */ new Set();
     return {
       Program: (node) => {
@@ -10615,8 +10844,8 @@ var gotPrefixRequiresSubmodelPayload = Rule_exports.define({
       CallExpression: (node) => {
         if (!isCallExpression(node)) return Effect_exports.void;
         return Effect_exports.forEach(
-          messageCases(node, messageUnionBindings),
-          (messageCase) => /^Got[A-Z]/.test(messageCase.name) && !hasMessagePayloadProperty(messageCase.fields) ? ctx.report(
+          messageCases(node, messageUnionBindings, references),
+          (messageCase) => /^Got[A-Z]/.test(messageCase.name) && !hasSubmodelMessagePayload(messageCase.fields, references) ? ctx.report(
             Diagnostic_exports.make({
               node: messageCase.nameNode,
               message: "Got* is reserved for Submodel wrappers. Add a { message: Child.Message } payload or choose a Message name that does not start with Got."
@@ -10638,6 +10867,8 @@ var gotSubmodelMessageName = Rule_exports.define({
   }),
   create: function* () {
     const ctx = yield* RuleContext;
+    const scopes = ctx.sourceCode.scopeManager?.scopes;
+    const references = scopes === void 0 ? void 0 : indexReferences(scopes);
     const messageUnionBindings = /* @__PURE__ */ new Set();
     return {
       Program: (node) => {
@@ -10647,8 +10878,8 @@ var gotSubmodelMessageName = Rule_exports.define({
       CallExpression: (node) => {
         if (!isCallExpression(node)) return Effect_exports.void;
         return Effect_exports.forEach(
-          messageCases(node, messageUnionBindings),
-          (messageCase) => hasMessagePayloadProperty(messageCase.fields) && !/^Got[A-Z].*Message$/.test(messageCase.name) ? ctx.report(
+          messageCases(node, messageUnionBindings, references),
+          (messageCase) => hasSubmodelMessagePayload(messageCase.fields, references) && !/^Got[A-Z].*Message$/.test(messageCase.name) ? ctx.report(
             Diagnostic_exports.make({
               node: messageCase.nameNode,
               message: "Submodel wrapper Messages should be named Got*Message so Foldkit DevTools can filter them."
@@ -10686,6 +10917,8 @@ var gotWrapperCarriesOnlyRouting = Rule_exports.define({
   }),
   create: function* () {
     const ctx = yield* RuleContext;
+    const scopes = ctx.sourceCode.scopeManager?.scopes;
+    const references = scopes === void 0 ? void 0 : indexReferences(scopes);
     const messageUnionBindings = /* @__PURE__ */ new Set();
     return {
       Program: (node) => {
@@ -10697,7 +10930,7 @@ var gotWrapperCarriesOnlyRouting = Rule_exports.define({
           return Effect_exports.void;
         }
         return Effect_exports.forEach(
-          messageCases(node, messageUnionBindings),
+          messageCases(node, messageUnionBindings, references),
           (messageCase) => gotWrapperTagPattern.test(messageCase.name) ? Effect_exports.forEach(
             messageCase.fields.properties,
             (property) => pipe(
@@ -10741,7 +10974,33 @@ var isArrowFunctionExpression = (node) => typeof node === "object" && node !== n
 var isBlockStatement = (node) => typeof node === "object" && node !== null && "type" in node && node.type === "BlockStatement";
 var isReturnStatement = (node) => typeof node === "object" && node !== null && "type" in node && node.type === "ReturnStatement";
 var isObjectPattern = (node) => typeof node === "object" && node !== null && "type" in node && node.type === "ObjectPattern";
-var isSingleValueMapCallee = (callee) => isMemberExpression(callee) && !callee.computed && isIdentifier(callee.property, "map") && isIdentifier(callee.object) && singleValueMapNamespaces.includes(callee.object.name);
+var isSingleValueMapCallee = (callee, references) => {
+  if (references === void 0) {
+    return isMemberExpression(callee) && !callee.computed && isIdentifier(callee.property, "map") && isIdentifier(callee.object) && singleValueMapNamespaces.includes(callee.object.name);
+  }
+  return Option_exports.exists(resolveImportedPath(references, callee), (path) => {
+    const isEffectModule = path.source === "effect" || path.source.startsWith("effect/");
+    const members = path.source.startsWith("effect/") ? [path.source.slice("effect/".length), ...path.members] : path.members;
+    const [namespace, methodName, extraMember] = members;
+    return isEffectModule && namespace !== void 0 && singleValueMapNamespaces.includes(namespace) && methodName === "map" && extraMember === void 0;
+  });
+};
+var isMapCallee = (callee, references) => {
+  if (calleeMatchesHelperName(callee, "map")) {
+    return true;
+  }
+  if (references === void 0) {
+    return false;
+  }
+  return Option_exports.exists(resolveImportedPath(references, callee), (path) => {
+    if (path.source !== "effect" && !path.source.startsWith("effect/")) {
+      return false;
+    }
+    const members = path.source.startsWith("effect/") ? [path.source.slice("effect/".length), ...path.members] : path.members;
+    const [namespace, methodName, extraMember] = members;
+    return namespace === "Array" && methodName === "map" && extraMember === void 0;
+  });
+};
 var arrowCallback = (node) => {
   const [firstArgument, secondArgument] = node.arguments;
   if (isArrowFunctionExpression(firstArgument)) {
@@ -10752,30 +11011,51 @@ var arrowCallback = (node) => {
   }
   return Option_exports.none();
 };
-var referencesIdOfParameter = (value, parameterName) => {
+var referencesIdOfParameter = (value, parameterName, references, parameterVariable) => {
   if (Array_exports.isArray(value)) {
     return value.some(
-      (element) => referencesIdOfParameter(element, parameterName)
+      (element) => referencesIdOfParameter(
+        element,
+        parameterName,
+        references,
+        parameterVariable
+      )
     );
   }
   if (typeof value !== "object" || value === null) {
     return false;
   }
-  if (isMemberExpression(value) && isIdentifier(value.object, parameterName) && isIdentifier(value.property, "id")) {
+  if (isMemberExpression(value) && isIdentifier(value.object, parameterName) && isIdentifier(value.property, "id") && (references === void 0 || parameterVariable !== void 0 && Option_exports.exists(
+    resolvedVariable(references, value.object),
+    (variable) => variable === parameterVariable
+  ))) {
     return true;
   }
   const fieldEntries = Object.entries(value);
   return fieldEntries.some(
-    ([fieldName, fieldValue]) => fieldName !== "parent" && referencesIdOfParameter(fieldValue, parameterName)
+    ([fieldName, fieldValue]) => fieldName !== "parent" && referencesIdOfParameter(
+      fieldValue,
+      parameterName,
+      references,
+      parameterVariable
+    )
   );
 };
 var destructuresId = (pattern) => pattern.properties.some(
   (property) => typeof property === "object" && property !== null && "key" in property && isIdentifier(property.key, "id")
 );
-var isIdentityBearing = (callback3) => {
+var isIdentityBearing = (callback3, references, declaredVariables) => {
   const [firstParameter] = callback3.params;
   if (isIdentifier(firstParameter)) {
-    return referencesIdOfParameter(callback3.body, firstParameter.name);
+    const parameterVariable = declaredVariables.find(
+      (variable) => variable.identifiers.some((identifier2) => identifier2 === firstParameter)
+    );
+    return referencesIdOfParameter(
+      callback3.body,
+      firstParameter.name,
+      references,
+      parameterVariable
+    );
   }
   if (isObjectPattern(firstParameter)) {
     return destructuresId(firstParameter);
@@ -10794,26 +11074,29 @@ var callbackReturnExpression = (callback3) => {
     )
   );
 };
-var isKeyedWrapped = (node) => isCallExpression(node.callee) && calleeMatchesHelperName(node.callee.callee, "keyed");
-var hasKeyAttribute = (rowElementCall) => {
+var isKeyedWrapped = (node, references) => isCallExpression(node.callee) && isFoldkitHtmlBuilderMember(node.callee.callee, "keyed", references);
+var hasKeyAttribute = (rowElementCall, references) => {
   const [attributesArgument] = rowElementCall.arguments;
   if (!isArrayExpression(attributesArgument)) {
     return false;
   }
   return attributesArgument.elements.some(
-    (element) => isCallExpression(element) && calleeMatchesHelperName(element.callee, "Key")
+    (element) => isCallExpression(element) && isFoldkitHtmlBuilderMember(element.callee, "Key", references)
   );
 };
-var unkeyedRowElement = (returnExpression) => {
+var unkeyedRowElement = (returnExpression, references) => {
   if (!isCallExpression(returnExpression)) {
     return Option_exports.none();
   }
-  if (isKeyedWrapped(returnExpression) || hasKeyAttribute(returnExpression)) {
+  if (isKeyedWrapped(returnExpression, references) || hasKeyAttribute(returnExpression, references)) {
     return Option_exports.none();
   }
   return pipe(
     helperCalleeName(returnExpression.callee),
     Option_exports.filter((tagName) => rowElementTagNames.includes(tagName)),
+    Option_exports.filter(
+      (tagName) => isFoldkitHtmlBuilderMember(returnExpression.callee, tagName, references)
+    ),
     Option_exports.map((tagName) => ({ rowElementCall: returnExpression, tagName }))
   );
 };
@@ -10825,16 +11108,26 @@ var keyedRequiredForMappedRows = Rule_exports.define({
   }),
   create: function* () {
     const ctx = yield* RuleContext;
+    const scopeManager = ctx.sourceCode.scopeManager;
+    const references = scopeManager === void 0 ? void 0 : indexReferences(scopeManager.scopes);
     return {
       CallExpression: (node) => {
-        if (!isCallExpression(node) || !calleeMatchesHelperName(node.callee, "map") || isSingleValueMapCallee(node.callee)) {
+        if (!isCallExpression(node) || !isMapCallee(node.callee, references) || isSingleValueMapCallee(node.callee, references)) {
           return Effect_exports.void;
         }
         return pipe(
           arrowCallback(node),
-          Option_exports.filter(isIdentityBearing),
+          Option_exports.filter(
+            (callback3) => isIdentityBearing(
+              callback3,
+              references,
+              scopeManager?.getDeclaredVariables(callback3) ?? []
+            )
+          ),
           Option_exports.flatMap(callbackReturnExpression),
-          Option_exports.flatMap(unkeyedRowElement),
+          Option_exports.flatMap(
+            (returnExpression) => unkeyedRowElement(returnExpression, references)
+          ),
           Option_exports.match({
             onNone: () => Effect_exports.void,
             onSome: ({ rowElementCall, tagName }) => ctx.report(
@@ -10877,16 +11170,19 @@ var childValuesOf = (node) => {
     Array_exports.flatMap(([key, value]) => key === "parent" ? [] : [value])
   );
 };
-var matchLazyFactoryCall = (node) => {
+var matchLazyFactoryCall = (node, references) => {
   const unwrapped = unwrapExpression(node);
   if (unwrapped.type !== "CallExpression") {
     return Option_exports.none();
   }
   const callee = unwrapExpression(unwrapped.callee);
-  if (callee.type !== "Identifier" || !isLazyFactoryName(callee.name)) {
-    return Option_exports.none();
+  if (references === void 0) {
+    return callee.type === "Identifier" && isLazyFactoryName(callee.name) ? Option_exports.some({ call: unwrapped, factoryName: callee.name }) : Option_exports.none();
   }
-  return Option_exports.some({ call: unwrapped, factoryName: callee.name });
+  return Option_exports.flatMap(resolveFoldkitApiPath(references, callee), (path) => {
+    const [namespace, factoryName, extraMember] = path;
+    return namespace === "Html" && factoryName !== void 0 && isLazyFactoryName(factoryName) && extraMember === void 0 ? Option_exports.some({ call: unwrapped, factoryName }) : Option_exports.none();
+  });
 };
 var declarationOf = (statement) => {
   if (statement.type === "VariableDeclaration") {
@@ -10897,7 +11193,7 @@ var declarationOf = (statement) => {
   }
   return Option_exports.none();
 };
-var registeredSlotsOf = (program) => pipe(
+var registeredSlotsOf = (program, references, scopeManager) => pipe(
   program.body,
   Array_exports.flatMap(
     (statement) => pipe(
@@ -10915,12 +11211,13 @@ var registeredSlotsOf = (program) => pipe(
     }
     const slotName = declarator.id.name;
     return pipe(
-      matchLazyFactoryCall(declarator.init),
+      matchLazyFactoryCall(declarator.init, references),
       Option_exports.match({
         onNone: () => [],
         onSome: (factoryCall) => [
           {
             slotName,
+            variable: scopeManager?.getDeclaredVariables(declarator).find((variable) => variable.name === slotName),
             viewArgumentIndex: VIEW_ARGUMENT_INDEX_BY_FACTORY[factoryCall.factoryName],
             initializerCall: factoryCall.call
           }
@@ -10965,12 +11262,16 @@ var functionBindingNames = (functionNode) => /* @__PURE__ */ new Set([
   ...bodyBindingNames(functionNode.body)
 ]);
 var isFunctionScopedName = (name, functionScopes) => functionScopes.some((scope3) => scope3.has(name));
+var isNestedInFunctionScope = (scope3) => scope3.type === "function" || scope3.upper !== null && isNestedInFunctionScope(scope3.upper);
+var isFunctionScopedView = (identifier2, context3) => context3.references === void 0 ? isFunctionScopedName(identifier2.name, context3.functionScopes) : Option_exports.exists(
+  resolvedVariable(context3.references, identifier2),
+  (variable) => isNestedInFunctionScope(variable.scope)
+);
 var MISPLACED_CREATION_MESSAGE = "`createLazy()` and `createKeyedLazy()` must be assigned directly to a module-scope `const`. A slot recreated inside a function starts with a cold cache on every call, so the memoization never hits.";
 var inlineViewFunctionMessage = (slotName) => `Lazy slot \`${slotName}\` is called with an inline view function. An inline function is a new reference on every render, so the cache never hits. Define the view function at module scope and pass its identifier.`;
 var functionScopedViewMessage = (slotName, viewName) => `Lazy slot \`${slotName}\` is called with \`${viewName}\`, which is bound inside an enclosing function. Function-scoped view functions get a fresh identity per render, so the cache never hits. Move \`${viewName}\` to module scope.`;
 var misplacedCreationOffenses = (node, context3) => {
-  const callee = unwrapExpression(node.callee);
-  if (callee.type !== "Identifier" || !isLazyFactoryName(callee.name)) {
+  if (Option_exports.isNone(matchLazyFactoryCall(node, context3.references))) {
     return [];
   }
   if (context3.registeredInitializers.has(node)) {
@@ -10980,7 +11281,7 @@ var misplacedCreationOffenses = (node, context3) => {
 };
 var unstableViewOffenses = (node, context3) => {
   const callee = unwrapExpression(node.callee);
-  if (callee.type !== "Identifier") {
+  if (!isIdentifierReference(callee)) {
     return [];
   }
   const maybeSlot = Option_exports.fromNullishOr(context3.slotsByName.get(callee.name));
@@ -10988,6 +11289,12 @@ var unstableViewOffenses = (node, context3) => {
     return [];
   }
   const { value: slot } = maybeSlot;
+  if (context3.references !== void 0 && (slot.variable === void 0 || !Option_exports.exists(
+    resolvedVariable(context3.references, callee),
+    (variable) => variable === slot.variable
+  ))) {
+    return [];
+  }
   const maybeViewArgument = Array_exports.get(node.arguments, slot.viewArgumentIndex);
   if (Option_exports.isNone(maybeViewArgument)) {
     return [];
@@ -11002,7 +11309,7 @@ var unstableViewOffenses = (node, context3) => {
       { node: viewArgument, message: inlineViewFunctionMessage(slot.slotName) }
     ];
   }
-  if (unwrappedViewArgument.type === "Identifier" && isFunctionScopedName(unwrappedViewArgument.name, context3.functionScopes)) {
+  if (isIdentifierReference(unwrappedViewArgument) && isFunctionScopedView(unwrappedViewArgument, context3)) {
     return [
       {
         node: viewArgument,
@@ -11056,12 +11363,18 @@ var lazyViewStableReferences = Rule_exports.define({
   }),
   create: function* () {
     const ctx = yield* RuleContext;
+    const scopes = ctx.sourceCode.scopeManager?.scopes;
+    const references = scopes === void 0 ? void 0 : indexReferences(scopes);
     return {
       "Program:exit": (node) => {
         if (!isProgram2(node)) {
           return Effect_exports.void;
         }
-        const registeredSlots = registeredSlotsOf(node);
+        const registeredSlots = registeredSlotsOf(
+          node,
+          references,
+          ctx.sourceCode.scopeManager
+        );
         const slotsByName = new Map(
           Array_exports.map(
             registeredSlots,
@@ -11074,7 +11387,8 @@ var lazyViewStableReferences = Rule_exports.define({
         const offenses = collectOffenses(node, {
           slotsByName,
           registeredInitializers,
-          functionScopes: []
+          functionScopes: [],
+          references
         });
         return Effect_exports.forEach(
           offenses,
@@ -11088,6 +11402,15 @@ var lazyViewStableReferences = Rule_exports.define({
 
 // src/rules/mount-factory-must-use-element.ts
 var MOUNT_DEFINITION_METHODS = ["define", "defineStream"];
+var isMountDefinitionCall = (node, references) => {
+  if (references === void 0) {
+    return AST_exports.isCallOf(node, "Mount", MOUNT_DEFINITION_METHODS);
+  }
+  return Option_exports.exists(resolveFoldkitApiPath(references, node.callee), (path) => {
+    const [namespace, methodName, extraMember] = path;
+    return namespace === "Mount" && methodName !== void 0 && MOUNT_DEFINITION_METHODS.includes(methodName) && extraMember === void 0;
+  });
+};
 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.`;
@@ -11205,9 +11528,11 @@ var mountFactoryMustUseElement = Rule_exports.define({
   }),
   create: function* () {
     const ctx = yield* RuleContext;
+    const scopes = ctx.sourceCode.scopeManager?.scopes;
+    const references = scopes === void 0 ? void 0 : indexReferences(scopes);
     return {
       CallExpression: (node) => {
-        if (!isCallExpression(node) || !AST_exports.isCallOf(node, "Mount", MOUNT_DEFINITION_METHODS)) {
+        if (!isCallExpression(node) || !isMountDefinitionCall(node, references)) {
           return Effect_exports.void;
         }
         return Option_exports.match(executeFunction(node), {
@@ -11226,7 +11551,16 @@ var mountFactoryMustUseElement = Rule_exports.define({
 var isProperty = (node) => typeof node === "object" && node !== null && "type" in node && node.type === "Property";
 var isArrowFunctionExpression2 = (node) => typeof node === "object" && node !== null && "type" in node && node.type === "ArrowFunctionExpression";
 var isVariableDeclarator2 = (node) => node.type === "VariableDeclarator";
-var mapCallbackIndexParameterName = (node) => {
+var isCreateKeyedLazyCall = (node, references) => {
+  if (references === void 0) {
+    return calleeMatchesHelperName(node.callee, "createKeyedLazy");
+  }
+  return Option_exports.exists(resolveFoldkitApiPath(references, node.callee), (path) => {
+    const [namespace, factoryName, extraMember] = path;
+    return namespace === "Html" && factoryName === "createKeyedLazy" && extraMember === void 0;
+  });
+};
+var mapCallbackIndexParameter = (node, scopeManager) => {
   if (!isArrowFunctionExpression2(node)) {
     return Option_exports.none();
   }
@@ -11246,7 +11580,9 @@ var mapCallbackIndexParameterName = (node) => {
   if (!isIdentifier(secondParameter)) {
     return Option_exports.none();
   }
-  return Option_exports.some(secondParameter.name);
+  const name = secondParameter.name;
+  const variable = scopeManager?.getDeclaredVariables(node).find((candidate) => candidate.name === name);
+  return Option_exports.some({ name, variable });
 };
 var firstNonSpreadArgument = (node) => {
   const [firstArgument] = node.arguments;
@@ -11261,61 +11597,75 @@ var slotIdValue = (configObject) => Option_exports.map(
   Array_exports.findFirst(configObject.properties, isSlotIdProperty),
   (property) => property.value
 );
-var keySinkExpression = (node, slotNames) => {
-  if (isCallExpression(node.callee) && calleeMatchesHelperName(node.callee.callee, "keyed")) {
+var keySinkExpression = (node, slots, references) => {
+  if (isCallExpression(node.callee) && isFoldkitHtmlBuilderMember(node.callee.callee, "keyed", references)) {
     return firstNonSpreadArgument(node);
   }
-  if (calleeMatchesHelperName(node.callee, "Key")) {
+  if (isFoldkitHtmlBuilderMember(node.callee, "Key", references)) {
     return firstNonSpreadArgument(node);
   }
-  if (calleeMatchesHelperName(node.callee, "submodel")) {
+  if (isFoldkitHtmlBuilderMember(node.callee, "submodel", references)) {
     const [configArgument] = node.arguments;
     if (isObjectExpression(configArgument)) {
       return slotIdValue(configArgument);
     }
   }
-  if (isIdentifier(node.callee) && slotNames.includes(node.callee.name)) {
-    return firstNonSpreadArgument(node);
+  if (isIdentifierReference(node.callee)) {
+    const slotCallee = node.callee;
+    const isRegisteredSlot = slots.some(
+      (slot) => slot.name === slotCallee.name && (references === void 0 || slot.variable !== void 0 && Option_exports.exists(
+        resolvedVariable(references, slotCallee),
+        (variable) => variable === slot.variable
+      ))
+    );
+    if (isRegisteredSlot) {
+      return firstNonSpreadArgument(node);
+    }
   }
   return Option_exports.none();
 };
-var referencesIndexName = (value, indexName) => {
+var referencesIndexBinding = (value, indexBinding, references) => {
   if (Array_exports.isArray(value)) {
-    return value.some((element) => referencesIndexName(element, indexName));
+    return value.some(
+      (element) => referencesIndexBinding(element, indexBinding, references)
+    );
   }
   if (typeof value !== "object" || value === null) {
     return false;
   }
-  if (isIdentifier(value, indexName)) {
-    return true;
+  if (isIdentifierReference(value) && value.name === indexBinding.name) {
+    return references === void 0 || indexBinding.variable !== void 0 && Option_exports.exists(
+      resolvedVariable(references, value),
+      (variable) => variable === indexBinding.variable
+    );
   }
   if (isMemberExpression(value)) {
-    if (referencesIndexName(value.object, indexName)) {
+    if (referencesIndexBinding(value.object, indexBinding, references)) {
       return true;
     }
-    return value.computed === true && referencesIndexName(value.property, indexName);
+    return value.computed === true && referencesIndexBinding(value.property, indexBinding, references);
   }
   if (isProperty(value)) {
-    if (value.computed === true && referencesIndexName(value.key, indexName)) {
+    if (value.computed === true && referencesIndexBinding(value.key, indexBinding, references)) {
       return true;
     }
-    return referencesIndexName(value.value, indexName);
+    return referencesIndexBinding(value.value, indexBinding, references);
   }
-  if (isArrowFunctionExpression2(value)) {
+  if (references === void 0 && isArrowFunctionExpression2(value)) {
     const parameters = value.params;
     const isShadowed = parameters.some(
-      (parameter) => isIdentifier(parameter, indexName)
+      (parameter) => isIdentifier(parameter, indexBinding.name)
     );
     if (isShadowed) {
       return false;
     }
   }
-  return referencesIndexNameAcrossFields(value, indexName);
+  return referencesIndexBindingAcrossFields(value, indexBinding, references);
 };
-var referencesIndexNameAcrossFields = (value, indexName) => {
+var referencesIndexBindingAcrossFields = (value, indexBinding, references) => {
   const fieldEntries = Object.entries(value);
   return fieldEntries.some(
-    ([fieldName, fieldValue]) => fieldName !== "parent" && referencesIndexName(fieldValue, indexName)
+    ([fieldName, fieldValue]) => fieldName !== "parent" && referencesIndexBinding(fieldValue, indexBinding, references)
   );
 };
 var noArrayIndexViewKeys = Rule_exports.define({
@@ -11326,24 +11676,31 @@ var noArrayIndexViewKeys = Rule_exports.define({
   }),
   create: function* () {
     const ctx = yield* RuleContext;
-    const indexNameStack = yield* Ref_exports.make([]);
-    const slotNames = yield* Ref_exports.make([]);
+    const scopes = ctx.sourceCode.scopeManager?.scopes;
+    const scopeManager = ctx.sourceCode.scopeManager;
+    const references = scopes === void 0 ? void 0 : indexReferences(scopes);
+    const indexBindingStack = yield* Ref_exports.make(
+      []
+    );
+    const slots = yield* Ref_exports.make([]);
     return {
       VariableDeclarator: (node) => {
-        if (!isVariableDeclarator2(node) || !isIdentifier(node.id) || !isCallExpression(node.init) || !calleeMatchesHelperName(node.init.callee, "createKeyedLazy")) {
+        if (!isVariableDeclarator2(node) || node.id.type !== "Identifier" || !isCallExpression(node.init) || !isCreateKeyedLazyCall(node.init, references)) {
           return Effect_exports.void;
         }
-        return Ref_exports.update(slotNames, Array_exports.append(node.id.name));
+        const slotName = node.id.name;
+        const variable = scopeManager?.getDeclaredVariables(node).find((candidate) => candidate.name === slotName);
+        return Ref_exports.update(slots, Array_exports.append({ name: slotName, variable }));
       },
-      ArrowFunctionExpression: (node) => Option_exports.match(mapCallbackIndexParameterName(node), {
+      ArrowFunctionExpression: (node) => Option_exports.match(mapCallbackIndexParameter(node, scopeManager), {
         onNone: () => Effect_exports.void,
-        onSome: (indexName) => Ref_exports.update(indexNameStack, Array_exports.append(indexName))
+        onSome: (indexBinding) => Ref_exports.update(indexBindingStack, Array_exports.append(indexBinding))
       }),
-      "ArrowFunctionExpression:exit": (node) => Option_exports.match(mapCallbackIndexParameterName(node), {
+      "ArrowFunctionExpression:exit": (node) => Option_exports.match(mapCallbackIndexParameter(node, scopeManager), {
         onNone: () => Effect_exports.void,
         onSome: () => Ref_exports.update(
-          indexNameStack,
-          (activeIndexNames) => Array_exports.dropRight(activeIndexNames, 1)
+          indexBindingStack,
+          (activeIndexBindings) => Array_exports.dropRight(activeIndexBindings, 1)
         )
       }),
       CallExpression: (node) => {
@@ -11351,30 +11708,31 @@ var noArrayIndexViewKeys = Rule_exports.define({
           return Effect_exports.void;
         }
         return Effect_exports.gen(function* () {
-          const activeIndexNames = yield* Ref_exports.get(indexNameStack);
-          if (Array_exports.isReadonlyArrayEmpty(activeIndexNames)) {
+          const activeIndexBindings = yield* Ref_exports.get(indexBindingStack);
+          if (Array_exports.isReadonlyArrayEmpty(activeIndexBindings)) {
             return;
           }
-          const registeredSlotNames = yield* Ref_exports.get(slotNames);
+          const registeredSlots = yield* Ref_exports.get(slots);
           const maybeKeyExpression = keySinkExpression(
             node,
-            registeredSlotNames
+            registeredSlots,
+            references
           );
           if (Option_exports.isNone(maybeKeyExpression)) {
             return;
           }
           const { value: keyExpression } = maybeKeyExpression;
-          const maybeIndexName = Array_exports.findFirst(
-            activeIndexNames,
-            (indexName) => referencesIndexName(keyExpression, indexName)
+          const maybeIndexBinding = Array_exports.findFirst(
+            activeIndexBindings,
+            (indexBinding) => referencesIndexBinding(keyExpression, indexBinding, references)
           );
-          if (Option_exports.isNone(maybeIndexName)) {
+          if (Option_exports.isNone(maybeIndexBinding)) {
             return;
           }
           yield* ctx.report(
             Diagnostic_exports.make({
               node: keyExpression,
-              message: `The array index parameter \`${maybeIndexName.value}\` is used as a view key. Positions shift when the list reorders or loses an item, so the runtime patches the wrong rows. Key this row or Submodel by a stable Model identifier such as \`item.id\` instead.`
+              message: `The array index parameter \`${maybeIndexBinding.value.name}\` is used as a view key. Positions shift when the list reorders or loses an item, so the runtime patches the wrong rows. Key this row or Submodel by a stable Model identifier such as \`item.id\` instead.`
             })
           );
         });
@@ -11385,40 +11743,211 @@ var noArrayIndexViewKeys = Rule_exports.define({
 
 // src/rules/no-child-message-construction-in-root.ts
 var pascalIdentifierPattern = /^[A-Z][A-Za-z0-9]*$/;
-var childMessageConstructionMessage = (namespace, constructorName2) => `Do not construct the child Message \`${namespace}.Message.${constructorName2}(...)\` from outside the child. Have the child export a helper that produces or applies this Message, and route child output back through the parent's Got*Message wrapper.`;
+var childMessageConstructionMessage = (calleeLabel) => `Do not construct the child Message \`${calleeLabel}(...)\` from a parent. Expose a child update capability that applies this fact, then invoke it with Update.foldChild or Update.foldChildStep. Child-owned views, Commands, and Subscriptions may construct their own Messages.`;
+var moduleExtensionPattern = /\.(?:cjs|cts|js|jsx|mjs|mts|ts|tsx)$/;
+var moduleSegmentName = (segment) => segment.replace(moduleExtensionPattern, "");
+var messageModuleSegmentNames = /* @__PURE__ */ new Set([
+  "index",
+  "main",
+  "message",
+  "schema"
+]);
+var isMessageModuleSegment = (segment) => segment !== void 0 && messageModuleSegmentNames.has(moduleSegmentName(segment).toLowerCase());
+var isFunction2 = (node) => typeof node === "object" && node !== null && "type" in node && (node.type === "ArrowFunctionExpression" || node.type === "FunctionDeclaration" || node.type === "FunctionExpression");
+var isTypeReference = (node) => typeof node === "object" && node !== null && "type" in node && node.type === "TSTypeReference";
+var isTypeAnnotatedIdentifier2 = (node) => isIdentifier(node);
+var importedMessagePath = (references, node) => isTypeReference(node) ? Option_exports.map(resolveImportedPath(references, node.typeName), (path) => ({
+  source: path.source,
+  members: path.members
+})) : Option_exports.none();
+var pascalCaseModuleSegment = (segment) => moduleSegmentName(segment).split(/[-_]/).map((part) => `${part.charAt(0).toUpperCase()}${part.slice(1)}`).join("");
+var messageModuleSegments = (path) => {
+  const sourceSegments = path.source.split("/").filter((segment) => segment !== ".");
+  const [lastSourceSegment] = sourceSegments.slice(-1);
+  const moduleSourceSegments = isMessageModuleSegment(lastSourceSegment) ? sourceSegments.slice(0, -1) : sourceSegments;
+  const namespaceMembers = path.members.slice(0, -1);
+  const [firstNamespaceMember] = namespaceMembers;
+  const [moduleSourceName] = moduleSourceSegments.slice(-1);
+  const remainingNamespaceMembers = firstNamespaceMember !== void 0 && moduleSourceName !== void 0 && pascalCaseModuleSegment(firstNamespaceMember) === pascalCaseModuleSegment(moduleSourceName) ? namespaceMembers.slice(1) : namespaceMembers;
+  return [...moduleSourceSegments, ...remainingNamespaceMembers].map(
+    pascalCaseModuleSegment
+  );
+};
+var sameSegments = (a, b) => Array_exports.length(a) === Array_exports.length(b) && Array_exports.every(Array_exports.zip(a, b), ([aSegment, bSegment]) => aSegment === bSegment);
+var sameImportedMessagePath = (a, b) => {
+  if (a.source === b.source && sameSegments(a.members, b.members)) {
+    return true;
+  }
+  const aSegments = messageModuleSegments(a);
+  const bSegments = messageModuleSegments(b);
+  return sameSegments(aSegments, bSegments);
+};
+var htmlBuilderMessagePath = (references, parameter) => {
+  if (!isTypeAnnotatedIdentifier2(parameter)) {
+    return Option_exports.none();
+  }
+  const typeAnnotation = parameter.typeAnnotation?.typeAnnotation;
+  if (!isTypeReference(typeAnnotation)) {
+    return Option_exports.none();
+  }
+  const isHtmlBuilder = Option_exports.exists(
+    resolveFoldkitApiPath(references, typeAnnotation.typeName),
+    (path) => {
+      const [namespace, typeName, extraMember] = path;
+      return namespace === "Html" && typeName === "HtmlBuilder" && extraMember === void 0;
+    }
+  );
+  if (!isHtmlBuilder) {
+    return Option_exports.none();
+  }
+  return Option_exports.gen(function* () {
+    const typeArguments = yield* Option_exports.fromNullishOr(
+      typeAnnotation.typeArguments
+    );
+    const messageType = yield* Option_exports.fromNullishOr(typeArguments.params[0]);
+    return yield* importedMessagePath(references, messageType);
+  });
+};
+var defineViewMessagePath = (references, functionNode) => {
+  const parent = functionNode.parent;
+  if (!isCallExpression(parent) || !parent.arguments.includes(functionNode)) {
+    return Option_exports.none();
+  }
+  const isDefineView = Option_exports.exists(
+    resolveFoldkitApiPath(references, parent.callee),
+    (path) => {
+      const [namespace, helperName, extraMember] = path;
+      return namespace === "Submodel" && helperName === "defineView" && extraMember === void 0;
+    }
+  );
+  if (!isDefineView) {
+    return Option_exports.none();
+  }
+  return Option_exports.gen(function* () {
+    const typeArguments = yield* Option_exports.fromNullishOr(parent.typeArguments);
+    const messageType = yield* Option_exports.fromNullishOr(typeArguments.params[1]);
+    return yield* importedMessagePath(references, messageType);
+  });
+};
+var isOwnedByEnclosingView = (node, references, messagePath) => {
+  const ownsMessage = (ancestor) => {
+    if (ancestor === null || ancestor === void 0) {
+      return false;
+    }
+    if (isFunction2(ancestor)) {
+      const ownsAnnotatedBuilder = ancestor.params.some(
+        (parameter) => Option_exports.exists(
+          htmlBuilderMessagePath(references, parameter),
+          (builderMessagePath) => sameImportedMessagePath(builderMessagePath, messagePath)
+        )
+      );
+      if (ownsAnnotatedBuilder) {
+        return true;
+      }
+      const ownsDefinedView = Option_exports.exists(
+        defineViewMessagePath(references, ancestor),
+        (viewMessagePath) => sameImportedMessagePath(viewMessagePath, messagePath)
+      );
+      if (ownsDefinedView) {
+        return true;
+      }
+    }
+    return ownsMessage(ancestor.parent);
+  };
+  return ownsMessage(node.parent);
+};
+var hasComputedMember = (node) => isMemberExpression(node) && (node.computed || hasComputedMember(node.object));
+var relativeModuleSegments = (source) => source.split("/").filter((segment) => segment !== "." && segment !== "..");
+var isTopLevelRootAlias = (source) => {
+  if (!source.startsWith("@/") && !source.startsWith("~/")) {
+    return false;
+  }
+  return !source.slice(2).includes("/");
+};
+var isRootMessageModule = (source) => {
+  const sourceSegments = relativeModuleSegments(source);
+  const [lastSourceSegment] = sourceSegments.slice(-1);
+  const [parentSourceSegment] = sourceSegments.slice(-2, -1);
+  if (lastSourceSegment === void 0) {
+    return true;
+  }
+  if (!isMessageModuleSegment(lastSourceSegment)) {
+    return false;
+  }
+  return source.startsWith(".") ? parentSourceSegment === void 0 : isTopLevelRootAlias(source);
+};
+var childNamespace = (source, importedMembers, localMembers) => {
+  const namespaceMembers = importedMembers.slice(0, -2);
+  const [importedNamespace] = namespaceMembers.slice(-1);
+  if (importedNamespace !== void 0) {
+    return importedNamespace;
+  }
+  const sourceSegments = relativeModuleSegments(source);
+  const [lastSourceSegment] = sourceSegments.slice(-1);
+  const [parentSourceSegment] = sourceSegments.slice(-2, -1);
+  const sourceNamespace = isMessageModuleSegment(lastSourceSegment) ? parentSourceSegment : lastSourceSegment;
+  if (sourceNamespace !== void 0) {
+    return pascalCaseModuleSegment(sourceNamespace);
+  }
+  const [localRoot] = localMembers;
+  return localRoot ?? "Child";
+};
+var childMessageConstruction = (callee, references) => {
+  if (hasComputedMember(callee)) {
+    return Option_exports.none();
+  }
+  if (references === void 0) {
+    return Option_exports.flatMap(staticMemberPath(callee), (path) => {
+      const [namespace, middle, constructorName2, extraSegment] = [
+        path.root.name,
+        ...path.members
+      ];
+      return namespace !== void 0 && middle === "Message" && constructorName2 !== void 0 && constructorName2 !== "Message" && extraSegment === void 0 && pascalIdentifierPattern.test(namespace) && pascalIdentifierPattern.test(constructorName2) ? Option_exports.some({
+        calleeLabel: `${namespace}.Message.${constructorName2}`
+      }) : Option_exports.none();
+    });
+  }
+  return Option_exports.flatMap(resolveImportedPath(references, callee), (path) => {
+    const [messageNamespace, constructorName2] = path.members.slice(-2);
+    if (messageNamespace !== "Message" || constructorName2 === void 0 || constructorName2 === "Message" || !pascalIdentifierPattern.test(constructorName2) || isRootMessageModule(path.source)) {
+      return Option_exports.none();
+    }
+    return Option_exports.some({
+      calleeLabel: `${childNamespace(path.source, path.members, path.localMembers)}.Message.${constructorName2}`,
+      messagePath: {
+        source: path.source,
+        members: path.members.slice(0, -1)
+      }
+    });
+  });
+};
 var noChildMessageConstructionInRoot = Rule_exports.define({
   name: "no-child-message-construction-in-root",
   meta: Rule_exports.meta({
     type: "suggestion",
-    description: "Construct child Submodel Messages through child-exported helpers instead of reaching into the child Message namespace."
+    description: "Drive child Submodels through child-owned update capabilities instead of constructing their Messages from a parent."
   }),
   create: function* () {
     const ctx = yield* RuleContext;
+    const scopes = ctx.sourceCode.scopeManager?.scopes;
+    const references = scopes === void 0 ? void 0 : indexReferences(scopes);
     return {
       CallExpression: (node) => {
         if (!isCallExpression(node)) {
           return Effect_exports.void;
         }
-        const callee = node.callee;
-        if (callee.type !== "MemberExpression") {
-          return Effect_exports.void;
-        }
         return pipe(
-          AST_exports.memberPath(callee),
+          childMessageConstruction(node.callee, references),
           Option_exports.match({
             onNone: () => Effect_exports.void,
-            onSome: (path) => {
-              const [namespace, middle, constructorName2, extraSegment] = path;
-              if (namespace === void 0 || middle !== "Message" || constructorName2 === void 0 || constructorName2 === "Message" || extraSegment !== void 0 || !pascalIdentifierPattern.test(namespace) || !pascalIdentifierPattern.test(constructorName2)) {
+            onSome: ({ calleeLabel, messagePath }) => {
+              if (references !== void 0 && messagePath !== void 0 && isOwnedByEnclosingView(node, references, messagePath)) {
                 return Effect_exports.void;
               }
               return ctx.report(
                 Diagnostic_exports.make({
                   node,
-                  message: childMessageConstructionMessage(
-                    namespace,
-                    constructorName2
-                  )
+                  message: childMessageConstructionMessage(calleeLabel)
                 })
               );
             }
@@ -11433,7 +11962,13 @@ var noChildMessageConstructionInRoot = Rule_exports.define({
 var FACTORY_NAMES = ["makeApplication", "makeElement"];
 var FREEZE_MODEL_MESSAGE = "`freezeModel: false` turns off Foldkit's dev mutation guard. When on, the runtime deep-freezes the Model after init and after every update, so an accidental mutation throws at the exact write site during development and costs nothing in production. Fix the mutation instead of disabling the guard. A deliberate disable belongs behind an oxlint-disable comment at this line.";
 var SLOW_MESSAGE = "`slow: false` turns off Foldkit's dev performance warnings, which flag update, view, and patch phases that blow their budgets. Tune instead of disabling: pass an object with thresholdOverrides, measuredPhases, show, or onSlow. A deliberate disable belongs behind an oxlint-disable comment at this line.";
-var isFactoryCallee = (callee) => {
+var isFactoryCallee = (callee, references) => {
+  if (references !== void 0) {
+    return Option_exports.exists(resolveFoldkitApiPath(references, callee), (path) => {
+      const [namespace, factoryName, extraMember] = path;
+      return namespace === "Runtime" && factoryName !== void 0 && FACTORY_NAMES.includes(factoryName) && extraMember === void 0;
+    });
+  }
   if (callee.type === "Identifier") {
     return FACTORY_NAMES.includes(callee.name);
   }
@@ -11475,9 +12010,11 @@ var noDisablingDevGuardrails = Rule_exports.define({
   }),
   create: function* () {
     const ctx = yield* RuleContext;
+    const scopes = ctx.sourceCode.scopeManager?.scopes;
+    const references = scopes === void 0 ? void 0 : indexReferences(scopes);
     return {
       CallExpression: (node) => {
-        if (!isCallExpression(node) || !isFactoryCallee(node.callee)) {
+        if (!isCallExpression(node) || !isFactoryCallee(node.callee, references)) {
           return Effect_exports.void;
         }
         const disabledGuardrails = node.arguments.flatMap((argument) => {
@@ -11501,19 +12038,8 @@ 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 `execute` never runs. Combine the behaviors into one Mount definition.";
-var isOnMountCallee = (callee) => {
-  if (callee.type === "Identifier") {
-    return callee.name === "OnMount";
-  }
-  if (callee.type === "MemberExpression") {
-    return Option_exports.match(AST_exports.memberPath(callee), {
-      onNone: () => false,
-      onSome: (path) => Array_exports.lastNonEmpty(path) === "OnMount"
-    });
-  }
-  return false;
-};
-var isOnMountCall = (element) => element !== null && element.type === "CallExpression" && isOnMountCallee(element.callee);
+var isOnMountCallee = (callee, references) => isFoldkitHtmlBuilderMember(callee, "OnMount", references);
+var isOnMountCall = (element, references) => element !== null && element.type === "CallExpression" && isOnMountCallee(element.callee, references);
 var noDuplicateOnmountPerElement = Rule_exports.define({
   name: "no-duplicate-onmount-per-element",
   meta: Rule_exports.meta({
@@ -11522,10 +12048,14 @@ var noDuplicateOnmountPerElement = Rule_exports.define({
   }),
   create: function* () {
     const ctx = yield* RuleContext;
+    const scopes = ctx.sourceCode.scopeManager?.scopes;
+    const references = scopes === void 0 ? void 0 : indexReferences(scopes);
     return {
       ArrayExpression: (node) => {
         if (!isArrayExpression(node)) return Effect_exports.void;
-        const onMountCallCount = node.elements.filter(isOnMountCall).length;
+        const onMountCallCount = node.elements.filter(
+          (element) => isOnMountCall(element, references)
+        ).length;
         if (onMountCallCount <= 1) return Effect_exports.void;
         return ctx.report(
           Diagnostic_exports.make({ node, message: DUPLICATE_ON_MOUNT_MESSAGE })
@@ -11757,27 +12287,38 @@ var ELEMENT_BUILDER_NAMES = /* @__PURE__ */ new Set([
 // src/rules/no-empty-children-array.ts
 var BUILDER_BINDINGS = /* @__PURE__ */ new Set(["h", "ih", "inertHtml"]);
 var KEYED_PROPERTY = "keyed";
-var builderCallee = (callee) => {
+var builderCallee = (callee, references) => {
   if (!isMemberExpression(callee) || callee.computed === true) {
     return Option_exports.none();
   }
-  if (!isIdentifier(callee.object) || !BUILDER_BINDINGS.has(callee.object.name) || !isIdentifier(callee.property)) {
+  if (!isIdentifier(callee.property)) {
+    return Option_exports.none();
+  }
+  const maybePath = staticMemberPath(callee);
+  if (Option_exports.isNone(maybePath)) {
+    return Option_exports.none();
+  }
+  const path = maybePath.value;
+  const binding = [path.root.name, ...Array_exports.dropRight(path.members, 1)].join(
+    "."
+  );
+  if (references === void 0 ? !BUILDER_BINDINGS.has(binding) : !isFoldkitHtmlBuilderMember(callee, callee.property.name, references)) {
     return Option_exports.none();
   }
   return Option_exports.some({
-    binding: callee.object.name,
+    binding,
     property: callee.property.name
   });
 };
-var elementCallTarget = (node) => node.arguments.length === 2 ? builderCallee(node.callee).pipe(
+var elementCallTarget = (node, references) => node.arguments.length === 2 ? builderCallee(node.callee, references).pipe(
   Option_exports.filter(({ property }) => ELEMENT_BUILDER_NAMES.has(property)),
   Option_exports.map(({ binding, property }) => `${binding}.${property}([...])`)
 ) : Option_exports.none();
-var keyedCallTarget = (node) => {
+var keyedCallTarget = (node, references) => {
   if (node.arguments.length !== 3 || !isCallExpression(node.callee)) {
     return Option_exports.none();
   }
-  return builderCallee(node.callee.callee).pipe(
+  return builderCallee(node.callee.callee, references).pipe(
     Option_exports.filter(({ property }) => property === KEYED_PROPERTY),
     Option_exports.map(
       ({ binding }) => `${binding}.${KEYED_PROPERTY}(tag)(key, [...])`
@@ -11794,14 +12335,16 @@ var noEmptyChildrenArray = Rule_exports.define({
   }),
   create: function* () {
     const ctx = yield* RuleContext;
+    const scopes = ctx.sourceCode.scopeManager?.scopes;
+    const references = scopes === void 0 ? void 0 : indexReferences(scopes);
     return {
       CallExpression: (node) => {
         if (!isCallExpression(node)) {
           return Effect_exports.void;
         }
         const maybeTarget = Option_exports.orElse(
-          elementCallTarget(node),
-          () => keyedCallTarget(node)
+          elementCallTarget(node, references),
+          () => keyedCallTarget(node, references)
         );
         if (Option_exports.isNone(maybeTarget)) {
           return Effect_exports.void;
@@ -11828,14 +12371,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 +12412,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)
@@ -11941,12 +12477,32 @@ var recordUnionHelperBindings = (bindings, node) => {
   }
 };
 var isConventionalUnionNamespace = (name) => PASCAL_CASE.test(name) && /(?:Message|Route|State)$/.test(name);
-var constructorName = (callee, unionNamespaces) => {
+var isUnionHelperCall = (node, bindings, references) => {
+  if (references === void 0) {
+    return isIdentifier(node.callee) && bindings.has(node.callee.name);
+  }
+  return Option_exports.exists(resolveFoldkitApiPath(references, node.callee), (path) => {
+    const [namespace, helperName, extraMember] = path;
+    const expectedHelperByNamespace = {
+      Message: "defineMessageUnion",
+      Route: "defineRouteUnion",
+      Schema: "defineTaggedUnion"
+    };
+    return namespace !== void 0 && expectedHelperByNamespace[namespace] === helperName && extraMember === void 0;
+  });
+};
+var constructorName = (callee, unionNamespaceNames, unionNamespaceVariables, references) => {
   if (isIdentifier(callee) && PASCAL_CASE.test(callee.name)) {
     return callee.name;
   }
-  if (isMemberExpression(callee) && callee.computed !== true && isIdentifier(callee.object) && (unionNamespaces.has(callee.object.name) || isConventionalUnionNamespace(callee.object.name)) && isIdentifier(callee.property) && PASCAL_CASE.test(callee.property.name)) {
-    return `${callee.object.name}.${callee.property.name}`;
+  if (isMemberExpression(callee) && callee.computed !== true && isIdentifierReference(callee.object) && isIdentifier(callee.property) && PASCAL_CASE.test(callee.property.name)) {
+    const namespace = callee.object;
+    const isUnionNamespace = references === void 0 ? unionNamespaceNames.has(namespace.name) || isConventionalUnionNamespace(namespace.name) : Option_exports.exists(resolvedVariable(references, namespace), (variable) => {
+      return unionNamespaceVariables.has(variable) || isConventionalUnionNamespace(namespace.name) && variable.defs.some(
+        (definition) => definition.type === "ImportBinding"
+      );
+    });
+    return isUnionNamespace ? `${namespace.name}.${callee.property.name}` : void 0;
   }
   return void 0;
 };
@@ -11958,16 +12514,24 @@ var noEmptyObjectTaggedCall = Rule_exports.define({
   }),
   create: function* () {
     const ctx = yield* RuleContext;
+    const scopes = ctx.sourceCode.scopeManager?.scopes;
+    const references = scopes === void 0 ? void 0 : indexReferences(scopes);
     const unionHelperBindings = /* @__PURE__ */ new Set();
-    const unionNamespaces = /* @__PURE__ */ new Set();
+    const unionNamespaceNames = /* @__PURE__ */ new Set();
+    const unionNamespaceVariables = /* @__PURE__ */ new Set();
     return {
       Program: (node) => {
         recordUnionHelperBindings(unionHelperBindings, node);
         return Effect_exports.void;
       },
       VariableDeclarator: (node) => {
-        if (isVariableDeclarator(node) && isIdentifier(node.id) && isCallExpression(node.init) && isIdentifier(node.init.callee) && unionHelperBindings.has(node.init.callee.name)) {
-          unionNamespaces.add(node.id.name);
+        if (isVariableDeclarator(node) && node.id.type === "Identifier" && isCallExpression(node.init) && isUnionHelperCall(node.init, unionHelperBindings, references)) {
+          const unionName = node.id.name;
+          unionNamespaceNames.add(unionName);
+          const unionVariable = ctx.sourceCode.scopeManager?.getDeclaredVariables(node).find((variable) => variable.name === unionName);
+          if (unionVariable !== void 0) {
+            unionNamespaceVariables.add(unionVariable);
+          }
         }
         return Effect_exports.void;
       },
@@ -11975,7 +12539,12 @@ var noEmptyObjectTaggedCall = Rule_exports.define({
         if (!isCallExpression(node)) {
           return Effect_exports.void;
         }
-        const name = constructorName(node.callee, unionNamespaces);
+        const name = constructorName(
+          node.callee,
+          unionNamespaceNames,
+          unionNamespaceVariables,
+          references
+        );
         if (name === void 0 || node.arguments.length !== 1) {
           return Effect_exports.void;
         }
@@ -11996,35 +12565,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 +12585,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 +12630,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 +12645,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({
@@ -12194,6 +12742,21 @@ var INTERNAL_NAVIGATION_FUNCTION_NAMES = [
 ];
 var INTERNAL_PATH_PATTERN = /^\//;
 var ABSOLUTE_URL_PATTERN = /^https?:\/\//;
+var routingFunctionName = (callee, references) => {
+  if (references === void 0) {
+    return pipe(
+      helperCalleeName(callee),
+      Option_exports.filter((name) => Array_exports.contains(ROUTING_FUNCTION_NAMES, name))
+    );
+  }
+  if (isFoldkitHtmlBuilderMember(callee, "Href", references)) {
+    return Option_exports.some("Href");
+  }
+  return Option_exports.flatMap(resolveFoldkitApiPath(references, callee), (path) => {
+    const [namespace, functionName, extraMember] = path;
+    return namespace === "Navigation" && functionName !== void 0 && Array_exports.contains(INTERNAL_NAVIGATION_FUNCTION_NAMES, functionName) && extraMember === void 0 ? Option_exports.some(functionName) : Option_exports.none();
+  });
+};
 var isHardcodedRouteString = (functionName, value) => INTERNAL_PATH_PATTERN.test(value) || Array_exports.contains(INTERNAL_NAVIGATION_FUNCTION_NAMES, functionName) && ABSOLUTE_URL_PATTERN.test(value);
 var templateCookedHead = (node) => pipe(
   Array_exports.head(node.quasis),
@@ -12209,15 +12772,14 @@ var noHardcodedRouteStrings = Rule_exports.define({
   }),
   create: function* () {
     const ctx = yield* RuleContext;
+    const scopes = ctx.sourceCode.scopeManager?.scopes;
+    const references = scopes === void 0 ? void 0 : indexReferences(scopes);
     return {
       CallExpression: (node) => {
         if (!isCallExpression2(node)) {
           return Effect_exports.void;
         }
-        const maybeFunctionName = pipe(
-          helperCalleeName(node.callee),
-          Option_exports.filter((name) => Array_exports.contains(ROUTING_FUNCTION_NAMES, name))
-        );
+        const maybeFunctionName = routingFunctionName(node.callee, references);
         if (Option_exports.isNone(maybeFunctionName)) {
           return Effect_exports.void;
         }
@@ -12260,6 +12822,602 @@ 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 isFunction3 = (node) => typeof node === "object" && node !== null && "type" in node && (node.type === "ArrowFunctionExpression" || node.type === "FunctionExpression" || node.type === "FunctionDeclaration");
+var isTransparentExpression2 = (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 innermostExpression2 = (node) => isTransparentExpression2(node) ? innermostExpression2(node.expression) : node;
+var outermostExpression = (node) => {
+  const parent = node.parent;
+  return isTransparentExpression2(parent) && parent.expression === node ? outermostExpression(parent) : node;
+};
+var staticPath = (node) => {
+  const expression = innermostExpression2(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 importedPath = (references, node) => references === void 0 ? Option_exports.map(staticPath(node), (path) => ({
+  source: "",
+  members: [path.root.name, ...path.members]
+})) : Option_exports.map(resolveImportedPath(references, node), (path) => ({
+  source: path.source,
+  members: 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(innermostExpression2(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 (isFunction3(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 +13487,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 +13505,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 +13513,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 +13543,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 }
@@ -12438,6 +13565,8 @@ var noNoopMessage = Rule_exports.define({
   }),
   create: function* () {
     const ctx = yield* RuleContext;
+    const scopes = ctx.sourceCode.scopeManager?.scopes;
+    const references = scopes === void 0 ? void 0 : indexReferences(scopes);
     const messageUnionBindings = /* @__PURE__ */ new Set();
     return {
       Program: (node) => {
@@ -12447,7 +13576,7 @@ var noNoopMessage = Rule_exports.define({
       CallExpression: (node) => {
         if (!isCallExpression(node)) return Effect_exports.void;
         return Effect_exports.forEach(
-          messageCases(node, messageUnionBindings),
+          messageCases(node, messageUnionBindings, references),
           (messageCase) => ["NoOp", "Noop", "NoOperation"].includes(messageCase.name) ? ctx.report(
             Diagnostic_exports.make({
               node: messageCase.nameNode,
@@ -12586,15 +13715,15 @@ var keyPropertyValue = (configObject) => Option_exports.map(
   Array_exports.findFirst(configObject.properties, isKeyProperty),
   (property) => property.value
 );
-var attributeEventName = (node) => {
-  if (!calleeMatchesHelperName(node.callee, "Attribute")) {
+var attributeEventName = (node, references) => {
+  if (!isFoldkitHtmlBuilderMember(node.callee, "Attribute", references)) {
     return Option_exports.none();
   }
   const [firstArgument] = node.arguments;
   return Option_exports.filter(staticStringValue(firstArgument), isRawEventName);
 };
-var propEventName = (node) => {
-  if (!calleeMatchesHelperName(node.callee, "Prop")) {
+var propEventName = (node, references) => {
+  if (!isFoldkitHtmlBuilderMember(node.callee, "Prop", references)) {
     return Option_exports.none();
   }
   const [configArgument] = node.arguments;
@@ -12615,14 +13744,16 @@ var noRawDomEventAttributes = Rule_exports.define({
   }),
   create: function* () {
     const ctx = yield* RuleContext;
+    const scopes = ctx.sourceCode.scopeManager?.scopes;
+    const references = scopes === void 0 ? void 0 : indexReferences(scopes);
     return {
       CallExpression: (node) => {
         if (!isCallExpression(node)) {
           return Effect_exports.void;
         }
         return pipe(
-          attributeEventName(node),
-          Option_exports.orElse(() => propEventName(node)),
+          attributeEventName(node, references),
+          Option_exports.orElse(() => propEventName(node, references)),
           Option_exports.match({
             onNone: () => Effect_exports.void,
             onSome: (attributeName) => ctx.report(
@@ -12640,7 +13771,16 @@ var noRawDomEventAttributes = Rule_exports.define({
 
 // src/rules/no-spread-in-evo.ts
 var nestedEvoMessage = (fieldName) => `The updater for field \`${fieldName}\` rebuilds the record with a spread, stepping outside the strict Model update path. Use a nested \`evo\` instead: \`${fieldName}: () => evo(model.${fieldName}, { ... })\`.`;
-var isEvoCall = (node) => {
+var isEvoCall = (node, references) => {
+  if (references !== void 0) {
+    return Option_exports.exists(
+      resolveFoldkitApiPath(references, node.callee),
+      (path) => {
+        const [namespace, methodName, extraMember] = path;
+        return namespace === "Struct" && methodName === "evo" && extraMember === void 0;
+      }
+    );
+  }
   const callee = node.callee;
   if (callee.type === "Identifier") {
     return callee.name === "evo";
@@ -12670,8 +13810,8 @@ var hasComputedKey = (objectExpression) => objectExpression.properties.some(
   (property) => property.type === "Property" && property.computed
 );
 var updaterFieldName = (property) => !property.computed && property.key.type === "Identifier" ? property.key.name : "<key>";
-var spreadRebuiltFields = (node) => {
-  if (!isEvoCall(node)) return [];
+var spreadRebuiltFields = (node, references) => {
+  if (!isEvoCall(node, references)) return [];
   const [, updates] = node.arguments;
   if (updates === void 0 || updates.type !== "ObjectExpression") return [];
   return updates.properties.flatMap((property) => {
@@ -12698,11 +13838,13 @@ var noSpreadInEvo = Rule_exports.define({
   }),
   create: function* () {
     const ctx = yield* RuleContext;
+    const scopes = ctx.sourceCode.scopeManager?.scopes;
+    const references = scopes === void 0 ? void 0 : indexReferences(scopes);
     return {
       CallExpression: (node) => {
         if (!isCallExpression(node)) return Effect_exports.void;
         return Effect_exports.forEach(
-          spreadRebuiltFields(node),
+          spreadRebuiltFields(node, references),
           ({ fieldName, bodyObject }) => ctx.report(
             Diagnostic_exports.make({
               node: bodyObject,
@@ -12776,16 +13918,149 @@ 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) => {
-  if (!isCallExpression(element) || !calleeMatchesHelperName(element.callee, "Target")) {
+var isTargetBlankElement = (element, references) => {
+  if (!isCallExpression(element) || !isFoldkitHtmlBuilderMember(element.callee, "Target", references)) {
     return false;
   }
   const [firstArgument] = element.arguments;
   return isStringLiteral(firstArgument) && firstArgument.value === "_blank";
 };
-var isRelElement = (element) => isCallExpression(element) && calleeMatchesHelperName(element.callee, "Rel");
+var isRelElement = (element, references) => isCallExpression(element) && isFoldkitHtmlBuilderMember(element.callee, "Rel", references);
 var relStaticValue = (relElement) => {
   const [firstArgument] = relElement.arguments;
   return staticStringValue(firstArgument);
@@ -12801,6 +14076,8 @@ var requireRelForExternalLink = Rule_exports.define({
   }),
   create: function* () {
     const ctx = yield* RuleContext;
+    const scopes = ctx.sourceCode.scopeManager?.scopes;
+    const references = scopes === void 0 ? void 0 : indexReferences(scopes);
     return {
       ArrayExpression: (node) => {
         if (!isArrayExpression(node)) {
@@ -12811,12 +14088,15 @@ var requireRelForExternalLink = Rule_exports.define({
         }
         const maybeTargetBlank = Array_exports.findFirst(
           node.elements,
-          isTargetBlankElement
+          (element) => isTargetBlankElement(element, references)
         );
         if (Option_exports.isNone(maybeTargetBlank)) {
           return Effect_exports.void;
         }
-        const relElements = Array_exports.filter(node.elements, isRelElement);
+        const relElements = Array_exports.filter(
+          node.elements,
+          (element) => isRelElement(element, references)
+        );
         if (Array_exports.isArrayEmpty(relElements)) {
           return ctx.report(
             Diagnostic_exports.make({
@@ -12905,39 +14185,57 @@ var isSelectionFactoryPath = (path) => {
     return first === "Ui" && second !== void 0 && multiSelectComponents.includes(second) && third === "Multi" && fourth === "create";
   }
   if (third !== void 0) {
-    const isMultiForm = second === "Multi" && multiSelectComponents.includes(first) && third === "create";
+    const isMultiForm = second === "Multi" && first !== void 0 && multiSelectComponents.includes(first) && third === "create";
     const isUiNamespaceForm = first === "Ui" && second !== void 0 && singleSelectComponents.includes(second) && third === "create";
     return isMultiForm || isUiNamespaceForm;
   }
-  return second === "create" && singleSelectComponents.includes(first);
+  return first !== void 0 && second === "create" && singleSelectComponents.includes(first);
 };
-var selectionFactoryLabel = (call) => pipe(
-  resolveMemberPath(call.callee),
-  Option_exports.filter(isSelectionFactoryPath),
-  Option_exports.map(Array_exports.join("."))
-);
-var selectionFactorySelfMatch = (value) => {
+var selectionFactoryLabel = (call, references) => {
+  const maybePath = references === void 0 ? resolveMemberPath(call.callee) : pipe(
+    resolveImportedPath(references, call.callee),
+    Option_exports.flatMap((path) => {
+      if (path.source === "@foldkit/ui") {
+        return Option_exports.some(path.members);
+      }
+      const componentBySource = {
+        "@foldkit/ui/combobox": "Combobox",
+        "@foldkit/ui/listbox": "Listbox",
+        "@foldkit/ui/menu": "Menu",
+        "@foldkit/ui/tabs": "Tabs"
+      };
+      const component = componentBySource[path.source];
+      return component === void 0 ? Option_exports.none() : Option_exports.some([component, ...path.members]);
+    })
+  );
+  return pipe(
+    maybePath,
+    Option_exports.filter(isSelectionFactoryPath),
+    Option_exports.map(Array_exports.join("."))
+  );
+};
+var selectionFactorySelfMatch = (value, references) => {
   if (!isCallExpression(value)) {
     return [];
   }
   const call = value;
   return pipe(
-    selectionFactoryLabel(call),
+    selectionFactoryLabel(call, references),
     Option_exports.match({
       onNone: () => [],
       onSome: (label) => [{ call, label }]
     })
   );
 };
-var collectSelectionFactoryCalls = (value) => {
+var collectSelectionFactoryCalls = (value, references) => {
   if (typeof value !== "object" || value === null) {
     return [];
   }
   const childEntries = Object.entries(value);
   const childMatches = childEntries.flatMap(
-    ([key, child]) => key === "parent" ? [] : collectSelectionFactoryCalls(child)
+    ([key, child]) => key === "parent" ? [] : collectSelectionFactoryCalls(child, references)
   );
-  return [...selectionFactorySelfMatch(value), ...childMatches];
+  return [...selectionFactorySelfMatch(value, references), ...childMatches];
 };
 var topLevelInitializerCalls = (program) => {
   const statements = program.body;
@@ -12962,12 +14260,14 @@ var selectionSubmodelFactoryAtModuleScope = Rule_exports.define({
   }),
   create: function* () {
     const ctx = yield* RuleContext;
+    const scopes = ctx.sourceCode.scopeManager?.scopes;
+    const references = scopes === void 0 ? void 0 : indexReferences(scopes);
     return Visitor_exports.onExit("Program", (node) => {
       if (!isProgram(node)) {
         return Effect_exports.void;
       }
       const allowedCalls = topLevelInitializerCalls(node);
-      const factoryCalls = collectSelectionFactoryCalls(node);
+      const factoryCalls = collectSelectionFactoryCalls(node, references);
       const offendingCalls = factoryCalls.filter(
         (factoryCall) => !allowedCalls.includes(factoryCall.call)
       );
@@ -13001,6 +14301,7 @@ var commandMapperPaths = [
 ];
 var gotMessagePattern = /^Got\w*Message$/;
 var dynamicCalleeLabel = "<dynamic call>";
+var emptyMessageUnionBindings = /* @__PURE__ */ new Set();
 var isWrapperExpression3 = (node) => typeof node === "object" && node !== null && "type" in node && typeof node.type === "string" && mapperWrapperTypes.includes(node.type) && "expression" in node;
 var unwrapExpression3 = (node) => isWrapperExpression3(node) ? unwrapExpression3(node.expression) : node;
 var isArrowFunctionExpression4 = (node) => typeof node === "object" && node !== null && "type" in node && node.type === "ArrowFunctionExpression";
@@ -13024,8 +14325,14 @@ var resolveMemberPath2 = (node) => {
   return Option_exports.none();
 };
 var isPropertyKeyNamed = (key, name) => isIdentifier(key, name) || isStringLiteral(key) && key.value === name;
-var commandMapperArrow = (node) => pipe(
-  resolveMemberPath2(node.callee),
+var foldkitApiPath = (node, references) => {
+  if (references === void 0) {
+    return resolveMemberPath2(node);
+  }
+  return resolveFoldkitApiPath(references, node);
+};
+var commandMapperArrow = (node, references) => pipe(
+  foldkitApiPath(node.callee, references),
   Option_exports.map(Array_exports.join(".")),
   Option_exports.filter((calleePath) => commandMapperPaths.includes(calleePath)),
   Option_exports.flatMap(() => {
@@ -13033,13 +14340,13 @@ var commandMapperArrow = (node) => pipe(
     return isArrowFunctionExpression4(mapperArgument) ? Option_exports.some(mapperArgument) : Option_exports.none();
   })
 );
-var subscriptionLiftMapperArrow = (node) => {
+var subscriptionLiftMapperArrow = (node, references) => {
   const innerCall = unwrapExpression3(node.callee);
   if (!isCallExpression(innerCall)) {
     return Option_exports.none();
   }
   return pipe(
-    resolveMemberPath2(innerCall.callee),
+    foldkitApiPath(innerCall.callee, references),
     Option_exports.map(Array_exports.join(".")),
     Option_exports.filter((calleePath) => calleePath === "Subscription.lift"),
     Option_exports.flatMap(() => {
@@ -13082,20 +14389,44 @@ var analyzableMapperCall = (arrow) => {
     })
   );
 };
-var nonGotMapperOffense = (arrow) => pipe(
+var isFoldkitMessageUnionVariable = (variable, references) => variable.defs.some(
+  (definition) => definition.type === "Variable" && isVariableDeclarator(definition.node) && isCallExpression(definition.node.init) && isFoldkitMessageUnionCall(
+    definition.node.init,
+    emptyMessageUnionBindings,
+    references
+  )
+);
+var nonGotMapperOffense = (arrow, references) => pipe(
   analyzableMapperCall(arrow),
-  Option_exports.flatMap(
-    (call) => pipe(
-      resolveMemberPath2(call.callee),
-      Option_exports.match({
-        onNone: () => Option_exports.some({ call, calleeLabel: dynamicCalleeLabel }),
-        onSome: (calleePath) => gotMessagePattern.test(Array_exports.lastNonEmpty(calleePath)) ? Option_exports.none() : Option_exports.some({
-          call,
-          calleeLabel: `${Array_exports.join(calleePath, ".")}(...)`
-        })
+  Option_exports.flatMap((call) => {
+    const maybeCalleePath = resolveMemberPath2(call.callee);
+    const isGotWrapper = references === void 0 ? Option_exports.exists(
+      maybeCalleePath,
+      (calleePath) => gotMessagePattern.test(Array_exports.lastNonEmpty(calleePath))
+    ) : Option_exports.exists(
+      resolveImportedPath(references, call.callee),
+      (importedPath2) => {
+        const [constructorName2] = importedPath2.members.slice(-1);
+        return constructorName2 !== void 0 && gotMessagePattern.test(constructorName2);
+      }
+    ) || Option_exports.exists(staticMemberPath(call.callee), (calleePath) => {
+      const [constructorName2, extraMember] = calleePath.members;
+      return constructorName2 !== void 0 && extraMember === void 0 && gotMessagePattern.test(constructorName2) && Option_exports.exists(
+        resolvedVariable(references, calleePath.root),
+        (variable) => isFoldkitMessageUnionVariable(variable, references)
+      );
+    });
+    if (isGotWrapper) {
+      return Option_exports.none();
+    }
+    return Option_exports.some({
+      call,
+      calleeLabel: Option_exports.match(maybeCalleePath, {
+        onNone: () => dynamicCalleeLabel,
+        onSome: (calleePath) => `${Array_exports.join(calleePath, ".")}(...)`
       })
-    )
-  )
+    });
+  })
 );
 var commandMapperMessage = (calleeLabel) => `This Command mapper must wrap child output in a Got*Message constructor. \`${calleeLabel}\` is not a Got wrapper, so this Submodel level never wraps its child's Messages. Route the child Message through the parent's Got*Message wrapper.`;
 var subscriptionMapperMessage = (calleeLabel) => `The toParentMessage mapper in Subscription.lift must wrap child output in a Got*Message constructor. \`${calleeLabel}\` is not a Got wrapper. Return the parent's Got*Message wrapper so each Submodel level wraps exactly once.`;
@@ -13107,6 +14438,9 @@ var wrapChildOutputInGotMessage = Rule_exports.define({
   }),
   create: function* () {
     const ctx = yield* RuleContext;
+    const scopeManager = ctx.sourceCode.scopeManager;
+    const scopes = scopeManager?.scopes;
+    const references = scopes === void 0 ? void 0 : indexReferences(scopes);
     const reportOffense = (offense, renderMessage) => ctx.report(
       Diagnostic_exports.make({
         node: offense.call,
@@ -13119,13 +14453,13 @@ var wrapChildOutputInGotMessage = Rule_exports.define({
           return Effect_exports.void;
         }
         return pipe(
-          commandMapperArrow(node),
-          Option_exports.flatMap(nonGotMapperOffense),
+          commandMapperArrow(node, references),
+          Option_exports.flatMap((arrow) => nonGotMapperOffense(arrow, references)),
           Option_exports.match({
             onSome: (offense) => reportOffense(offense, commandMapperMessage),
             onNone: () => pipe(
-              subscriptionLiftMapperArrow(node),
-              Option_exports.flatMap(nonGotMapperOffense),
+              subscriptionLiftMapperArrow(node, references),
+              Option_exports.flatMap((arrow) => nonGotMapperOffense(arrow, references)),
               Option_exports.match({
                 onSome: (offense) => reportOffense(offense, subscriptionMapperMessage),
                 onNone: () => Effect_exports.void
@@ -13161,12 +14495,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
@@ -13183,22 +14519,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) => ({
@@ -13207,7 +14559,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,