@akanjs/language 3.2.0-rc.0 → 3.2.0-rc.10

package/index.js

@@ -8,7 +8,8 @@ var isEdited = (before, after) => before.digest !== undefined && after.digest !=
 var byId = (a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
 
 class AkanGraphDiff {
-  static between(base, head) {
+  static between(given, head) {
+    const base = AkanGraphDiff.#renamed(given, head);
     const baseNodes = new Map(base.nodes.map((node) => [node.id, node]));
     const headNodes = new Map(head.nodes.map((node) => [node.id, node]));
     const marked = new Map;
@@ -27,6 +28,9 @@ class AkanGraphDiff {
       ...head.edges.flatMap((edge) => !baseKeys.has(edgeKeyOf(edge)) ? [{ ...edge, change: "added" }] : marked.has(edge.from) || marked.has(edge.to) ? [edge] : []),
       ...base.edges.filter((edge) => !headKeys.has(edgeKeyOf(edge))).map((edge) => ({ ...edge, change: "removed" }))
     ];
+    const shown = new Set([...marked.keys(), ...edges.flatMap((edge) => [edge.from, edge.to])]);
+    const listed = new Set(edges.map(edgeKeyOf));
+    edges.push(...head.edges.filter((edge) => edge.kind === "binds" && shown.has(edge.from) && !listed.has(edgeKeyOf(edge))));
     const context = edges.flatMap((edge) => [edge.from, edge.to]).filter((id) => !marked.has(id)).flatMap((id) => {
       const node = headNodes.get(id) ?? baseNodes.get(id);
       return node ? [node] : [];
@@ -38,6 +42,40 @@ class AkanGraphDiff {
         summary[node.change] += 1;
     return { version: 1, nodes, edges, summary };
   }
+  static #renamed(base, head) {
+    const baseIds = new Set(base.nodes.map((node) => node.id));
+    const headIds = new Set(head.nodes.map((node) => node.id));
+    const pairKeyOf = ({ kind, owner, name, at }) => at ? `${kind}
+${owner ?? ""}
+${name}
+${at.file}` : null;
+    const shortIdOf = ({ kind, owner, name }) => `${kind}:${owner ?? ""}:${name}`;
+    const isFileKeyed = (node) => node.id !== shortIdOf(node) && node.id.startsWith(`${node.kind}:${node.owner ?? ""}:`) && node.id.endsWith(`#${node.name}`);
+    const fromBase = new Map(base.nodes.flatMap((node) => {
+      const key = headIds.has(node.id) ? null : pairKeyOf(node);
+      return key ? [[key, node]] : [];
+    }));
+    const renames = new Map;
+    for (const node of head.nodes) {
+      if (baseIds.has(node.id))
+        continue;
+      const key = pairKeyOf(node);
+      const before = key ? fromBase.get(key) : undefined;
+      if (!before)
+        continue;
+      const isPair = isFileKeyed(node) ? before.id === shortIdOf(node) : isFileKeyed(before) && node.id === shortIdOf(before);
+      if (isPair)
+        renames.set(before.id, node.id);
+    }
+    if (!renames.size)
+      return base;
+    const rename = (id) => renames.get(id) ?? id;
+    return {
+      ...base,
+      nodes: base.nodes.map((node) => renames.has(node.id) ? { ...node, id: rename(node.id) } : node),
+      edges: base.edges.map((edge) => ({ ...edge, from: rename(edge.from), to: rename(edge.to) }))
+    };
+  }
   static #mark(node, change) {
     return node.fields ? { ...node, change, fields: node.fields.map((field) => ({ ...field, change })) } : { ...node, change };
   }
@@ -71,6 +109,261 @@ class AkanGraphDiff {
     return node.fields ? { ...node, fields: node.fields.map(({ digest: _field, ...field }) => field) } : node;
   }
 }
+// pkgs/@akanjs/language/escapeRegExp.ts
+var regExpSpecials = /[\\^$.*+?()[\]{}|]/g;
+var escapeRegExp = (text) => text.replace(regExpSpecials, (special) => `\\${special}`);
+
+// pkgs/@akanjs/language/guardFacts.ts
+var guardLabelOf = (guard, labels) => {
+  const [, role = null, local = guard] = guard.match(/^([\w$]+) (.+)$/) ?? [];
+  const label = labels[local];
+  return label === undefined ? guard : role ? `${role} ${label}` : label;
+};
+var maxLabelArgs = 32;
+var maxLayers = 4;
+var guardRefReaderOf = (ts, ast, unwrap) => {
+  const pathOf = (expression) => {
+    if (ts.isIdentifier(expression))
+      return expression.text;
+    if (!ts.isPropertyAccessExpression(expression))
+      return null;
+    const head = pathOf(expression.expression);
+    return head && `${head}.${expression.name.text}`;
+  };
+  const layersOf = (call) => {
+    const inner = unwrap(call.expression);
+    if (!ts.isCallExpression(inner))
+      return { root: call, layers: 0 };
+    const { root, layers } = layersOf(inner);
+    return { root, layers: layers + 1 };
+  };
+  const calleeOf = (call) => pathOf(unwrap(layersOf(call).root.expression)) ?? "?";
+  const labelOf = (source, call) => {
+    const args = call.arguments.map((arg) => arg.getText(source)).join(", ");
+    const inner = unwrap(call.expression);
+    const head = ts.isCallExpression(inner) ? labelOf(source, inner) : pathOf(inner) ?? "?";
+    return `${head}(${args.length <= maxLabelArgs && !args.includes(`
+`) ? args : "…"})`;
+  };
+  const guardRefOf = (expression, made, member) => {
+    const value = unwrap(expression);
+    if (!ts.isCallExpression(value))
+      return pathOf(value) ?? ast.expressionName(value);
+    const prefix = `${member}:${calleeOf(value)}@`;
+    const name = `${prefix}${made.filter((other) => other.name.startsWith(prefix)).length + 1}`;
+    made.push({ call: value, name });
+    return name;
+  };
+  const guardsIn = (source, object, made, member) => {
+    const guards = object?.properties.find((property) => ts.isPropertyAssignment(property) && ast.nodeName(property.name) === "guards")?.initializer;
+    if (!guards)
+      return [];
+    const refOf = (expression) => guardRefOf(expression, made, member);
+    if (ts.isArrayLiteralExpression(guards))
+      return guards.elements.map(refOf).filter((name) => name !== null);
+    if (ts.isObjectLiteralExpression(guards))
+      return guards.properties.filter(ts.isPropertyAssignment).flatMap((property) => {
+        const value = unwrap(property.initializer);
+        const names = ts.isArrayLiteralExpression(value) ? value.elements.map(refOf) : [refOf(value)];
+        return names.map((name) => `${ast.nodeName(property.name)} ${name ?? "?"}`);
+      });
+    const single = refOf(guards);
+    return single ? [single] : [];
+  };
+  return { pathOf, layersOf, labelOf, guardsIn };
+};
+var guardFactoryReaderOf = (ts, ast, { spanOf, extentOf, unwrap, docOf }, pathOf, layersOf) => {
+  const implementsGuard = (node, guardNames) => !!node.heritageClauses?.some((clause) => clause.token === ts.SyntaxKind.ImplementsKeyword && clause.types.some(({ expression }) => guardNames.has(ast.expressionName(expression) ?? "")));
+  const scopeOf = (node) => {
+    const scope = node.members.find((member) => ts.isPropertyDeclaration(member) && ast.nodeName(member.name) === "scope" && !!ts.getModifiers(member)?.some(({ kind }) => kind === ts.SyntaxKind.StaticKeyword))?.initializer;
+    const value = scope && unwrap(scope);
+    return value && ts.isStringLiteralLike(value) ? value.text : null;
+  };
+  const functionsOf = (source) => {
+    const functions = new Map;
+    for (const statement of source.statements) {
+      if (ts.isFunctionDeclaration(statement) && statement.name && statement.body)
+        functions.set(statement.name.text, { statement, name: statement.name, body: statement.body });
+      if (!ts.isVariableStatement(statement))
+        continue;
+      for (const declaration of statement.declarationList.declarations) {
+        const initializer = declaration.initializer && unwrap(declaration.initializer);
+        if (initializer && ts.isIdentifier(declaration.name) && (ts.isArrowFunction(initializer) || ts.isFunctionExpression(initializer)))
+          functions.set(declaration.name.text, { statement, name: declaration.name, body: initializer.body });
+      }
+    }
+    return functions;
+  };
+  const returnedOf = (body, guardNames, depth = 0) => {
+    const locals = new Map;
+    const pending = [];
+    const visit = (node) => {
+      if (ts.isClassDeclaration(node) && node.name)
+        locals.set(node.name.text, node);
+      if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer)
+        locals.set(node.name.text, node.initializer);
+      if (ts.isReturnStatement(node) && node.expression)
+        pending.push(node.expression);
+      if (!ts.isFunctionLike(node) && !ts.isClassLike(node))
+        ts.forEachChild(node, visit);
+    };
+    if (ts.isBlock(body))
+      ts.forEachChild(body, visit);
+    else
+      pending.push(body);
+    let guard = null;
+    const calls = [];
+    const seen = new Set;
+    const passed = new Set;
+    const returned = [];
+    for (let node = pending.pop();node; node = pending.pop()) {
+      if (seen.has(node))
+        continue;
+      seen.add(node);
+      const value = ts.isExpression(node) ? unwrap(node) : node;
+      if ((ts.isClassExpression(value) || ts.isClassDeclaration(value)) && implementsGuard(value, guardNames))
+        guard ??= value;
+      else if ((ts.isArrowFunction(value) || ts.isFunctionExpression(value)) && !passed.has(node) && depth < maxLayers)
+        returned.push(value.body);
+      else if (ts.isConditionalExpression(value))
+        pending.push(value.whenTrue, value.whenFalse);
+      else if (ts.isBinaryExpression(value))
+        pending.push(value.left, value.right);
+      else if (ts.isIdentifier(value)) {
+        const local = locals.get(value.text);
+        if (local)
+          pending.push(local);
+      } else if (ts.isCallExpression(value)) {
+        const { root, layers } = layersOf(value);
+        const callee = pathOf(unwrap(root.expression));
+        if (callee && !passed.has(node) && !calls.some((call) => call.callee === callee))
+          calls.push({ callee, layers });
+        for (let call = value;ts.isCallExpression(call); call = unwrap(call.expression)) {
+          for (const arg of call.arguments)
+            passed.add(arg);
+          pending.push(...call.arguments);
+        }
+      }
+    }
+    const [inner] = returned;
+    if (guard || calls.length || !inner)
+      return { guard, calls, layers: 0 };
+    const nested = returnedOf(inner, guardNames, depth + 1);
+    return { ...nested, layers: nested.layers + 1 };
+  };
+  const guardFactoriesOf = (source, guardNames, isImported) => {
+    const functions = functionsOf(source);
+    const returned = new Map([...functions].map(([name, { body }]) => [name, returnedOf(body, guardNames)]));
+    const members = new Set;
+    const isFactoryCall = (callee) => members.has(callee) || !functions.has(callee) && isImported(callee);
+    for (let isGrowing = true;isGrowing; ) {
+      isGrowing = false;
+      for (const [name, { guard, calls }] of returned) {
+        if (members.has(name) || !guard && !calls.some(({ callee }) => isFactoryCall(callee)))
+          continue;
+        members.add(name);
+        isGrowing = true;
+      }
+    }
+    const factories = new Map;
+    for (const name of members) {
+      const found = functions.get(name);
+      const made = returned.get(name);
+      if (!found || !made)
+        continue;
+      factories.set(name, {
+        name,
+        span: spanOf(source, found.name),
+        extent: extentOf(source, found.statement),
+        scope: made.guard ? scopeOf(made.guard) : null,
+        doc: docOf(source, found.statement),
+        direct: !!made.guard,
+        via: made.calls.filter(({ callee }) => isFactoryCall(callee)),
+        layers: made.layers
+      });
+    }
+    return factories;
+  };
+  return { implementsGuard, scopeOf, guardFactoriesOf };
+};
+var createGuardFactReader = (ts, ast, base) => {
+  const { spanOf, extentOf, unwrap, docOf } = base;
+  const { pathOf, layersOf, labelOf, guardsIn } = guardRefReaderOf(ts, ast, unwrap);
+  const { implementsGuard, scopeOf, guardFactoriesOf } = guardFactoryReaderOf(ts, ast, base, pathOf, layersOf);
+  const guardsOf = (source, imports, madeInPlace) => {
+    const guardNames = new Set([
+      "Guard",
+      ...imports.filter(({ imported }) => imported === "Guard").map(({ name }) => name)
+    ]);
+    const imported = new Set(imports.map(({ name }) => name));
+    const isImported = (callee) => imported.has(callee.split(".")[0] ?? callee);
+    const factories = guardFactoriesOf(source, guardNames, isImported);
+    const guards = [];
+    const calls = [];
+    const makeOf = (made, value, isInPlace = false) => {
+      if (ts.isClassExpression(value) && implementsGuard(value, guardNames)) {
+        guards.push({ ...made, scope: scopeOf(value), factory: null, layers: 0 });
+        return;
+      }
+      const { root, layers } = ts.isCallExpression(value) ? layersOf(value) : { root: null, layers: 0 };
+      const callee = root && pathOf(unwrap(root.expression));
+      const factory = callee && factories.get(callee);
+      if (factory)
+        guards.push({ ...made, scope: factory.scope, factory: factory.name, layers });
+      else if (callee && (isImported(callee) || isInPlace))
+        calls.push({ ...made, callee, kind: "call", scope: null, layers });
+    };
+    for (const statement of source.statements) {
+      if (ts.isClassDeclaration(statement) && statement.name) {
+        const declared = {
+          name: statement.name.text,
+          span: spanOf(source, statement.name),
+          extent: extentOf(source, statement),
+          scope: scopeOf(statement),
+          doc: docOf(source, statement)
+        };
+        const base = statement.heritageClauses?.find(({ token }) => token === ts.SyntaxKind.ExtendsKeyword)?.types[0];
+        const callee = base && pathOf(base.expression);
+        if (implementsGuard(statement, guardNames))
+          guards.push({ ...declared, factory: null, layers: 0 });
+        else if (callee)
+          calls.push({ ...declared, callee, kind: "extends", layers: 0 });
+      }
+      if (!ts.isVariableStatement(statement))
+        continue;
+      for (const declaration of statement.declarationList.declarations) {
+        const initializer = declaration.initializer && unwrap(declaration.initializer);
+        if (!initializer || !ts.isIdentifier(declaration.name))
+          continue;
+        const holder = declaration.name.text;
+        makeOf({
+          name: holder,
+          span: spanOf(source, declaration.name),
+          extent: extentOf(source, statement),
+          doc: docOf(source, statement)
+        }, initializer);
+        if (!ts.isObjectLiteralExpression(initializer))
+          continue;
+        for (const property of initializer.properties) {
+          const key = ts.isPropertyAssignment(property) ? ast.nodeName(property.name) : null;
+          if (key && ts.isPropertyAssignment(property))
+            makeOf({
+              name: `${holder}.${key}`,
+              span: spanOf(source, property.name),
+              extent: extentOf(source, property),
+              doc: docOf(source, property)
+            }, unwrap(property.initializer));
+        }
+      }
+    }
+    for (const { call, name } of madeInPlace)
+      makeOf({ name, span: spanOf(source, call), extent: extentOf(source, call), doc: null }, call, true);
+    const guardLabels = Object.fromEntries(madeInPlace.map(({ call, name }) => [name, labelOf(source, call)]));
+    return { guards, guardFactories: [...factories.values()], guardCalls: calls, guardLabels };
+  };
+  return { guardsIn, guardsOf };
+};
+
 // pkgs/@akanjs/language/moduleFacts.ts
 var testFilePattern = /\.(?:test|spec)\.tsx?$/;
 var moduleCallees = new Set([
@@ -139,21 +432,6 @@ var createFactReader = (ts, ast) => {
     const value = unwrap(expression);
     return ts.isPropertyAccessExpression(value) && ts.isIdentifier(value.expression) ? `${value.expression.text}.${value.name.text}` : ast.expressionName(value);
   };
-  const guardsIn = (object) => {
-    const guards = object?.properties.find((property) => ts.isPropertyAssignment(property) && ast.nodeName(property.name) === "guards")?.initializer;
-    if (!guards)
-      return [];
-    if (ts.isArrayLiteralExpression(guards))
-      return guards.elements.map(guardNameOf).filter((name) => name !== null);
-    if (ts.isObjectLiteralExpression(guards))
-      return guards.properties.filter(ts.isPropertyAssignment).flatMap((property) => {
-        const value = unwrap(property.initializer);
-        const names = ts.isArrayLiteralExpression(value) ? value.elements.map(guardNameOf) : [guardNameOf(value)];
-        return names.map((name) => `${ast.nodeName(property.name)} ${name ?? "?"}`);
-      });
-    const single = guardNameOf(guards);
-    return single ? [single] : [];
-  };
   const optionObjectOf = (call) => call.arguments.find((arg) => ts.isObjectLiteralExpression(arg) && arg.properties.some((property) => ast.propertyName(property) === "guards"));
   const chainOf = (initializer) => {
     let root = unwrap(initializer);
@@ -170,7 +448,7 @@ var createFactReader = (ts, ast) => {
     const node = keyName(property);
     return name && node ? [{ name, span: spanOf(source, node), extent: extentOf(source, property) }] : [];
   });
-  const sliceKeysOf = (source, builder) => (returnedObject(builder)?.properties ?? []).flatMap((property) => {
+  const sliceKeysOf = (source, builder, made, model) => (returnedObject(builder)?.properties ?? []).flatMap((property) => {
     if (!ts.isPropertyAssignment(property))
       return [];
     const name = ast.nodeName(property.name);
@@ -182,7 +460,7 @@ var createFactReader = (ts, ast) => {
         name,
         span: spanOf(source, property.name),
         extent: extentOf(source, property),
-        guards: root ? guardsIn(optionObjectOf(root)) : [],
+        guards: root ? guardsIn(source, optionObjectOf(root), made, `${model}.${name}`) : [],
         live: methods.includes("live"),
         argCount: methods.filter((method) => argMethods.has(method)).length
       }
@@ -232,7 +510,7 @@ var createFactReader = (ts, ast) => {
     const [size, unit] = intervalUnits.find(([size]) => ms >= size && ms % size === 0) ?? [1, "ms"];
     return `${ms / size}${unit}`;
   };
-  const modesOf = (option) => {
+  const modesOf = (option, type) => {
     const object = option && unwrap(option);
     if (!object || !ts.isObjectLiteralExpression(object))
       return [];
@@ -242,9 +520,9 @@ var createFactReader = (ts, ast) => {
       if (name === "enabled")
         return value.kind === ts.SyntaxKind.FalseKeyword ? ["disabled"] : [];
       if (name === "once")
-        return value.kind === ts.SyntaxKind.TrueKeyword ? ["once"] : [];
+        return type === "initialize" && value.kind === ts.SyntaxKind.TrueKeyword ? ["once"] : [];
       if (name === "lock")
-        return value.kind === ts.SyntaxKind.FalseKeyword ? ["unlocked"] : [];
+        return type === "interval" && value.kind === ts.SyntaxKind.FalseKeyword ? ["unlocked"] : [];
       if (name !== "serverMode" && name !== "operationMode")
         return [];
       const values = ts.isArrayLiteralExpression(value) ? [...value.elements] : [value];
@@ -262,7 +540,8 @@ var createFactReader = (ts, ast) => {
       const { root } = chainOf(property.initializer);
       const type = root ? verbOf(root.expression) : null;
       const [first, second] = root?.arguments ?? [];
-      const schedule = type === "cron" && first ? ts.isStringLiteralLike(first) ? first.text : first.getText(source) : type === "interval" || type === "timeout" ? durationOf(first, source) : null;
+      const cron = type === "cron" && first ? unwrap(first) : null;
+      const schedule = cron ? ts.isStringLiteralLike(cron) ? cron.text : cron.getText(source) : type === "interval" || type === "timeout" ? durationOf(first, source) : null;
       const option = type === "initialize" || type === "destroy" ? first : second;
       return [
         {
@@ -271,7 +550,7 @@ var createFactReader = (ts, ast) => {
           extent: extentOf(source, property),
           type,
           schedule,
-          modes: modesOf(option)
+          modes: modesOf(option, type)
         }
       ];
     });
@@ -288,7 +567,20 @@ var createFactReader = (ts, ast) => {
       return name && targetName ? [{ name, span: spanOf(source, property.name), target: targetName }] : [];
     });
   };
-  const endpointKeysOf = (source, builder) => {
+  const adaptorBindingsIn = (source) => {
+    const bindings = [];
+    const visit = (node) => {
+      if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === "applyAdaptor") {
+        const [role, adaptor] = node.arguments.map(guardNameOf);
+        if (role && adaptor)
+          bindings.push({ role, adaptor, span: spanOf(source, node.expression.name) });
+      }
+      ts.forEachChild(node, visit);
+    };
+    visit(source);
+    return bindings;
+  };
+  const endpointKeysOf = (source, builder, made, model) => {
     const verbOf = verbReaderOf(builder?.parameters[0]);
     return (returnedObject(builder)?.properties ?? []).flatMap((property) => {
       if (!ts.isPropertyAssignment(property))
@@ -303,7 +595,7 @@ var createFactReader = (ts, ast) => {
           span: spanOf(source, property.name),
           extent: extentOf(source, property),
           verb: root ? verbOf(root.expression) : null,
-          guards: root ? guardsIn(optionObjectOf(root)) : [],
+          guards: root ? guardsIn(source, optionObjectOf(root), made, `${model}.${name}`) : [],
           argCount: methods.filter((method) => argMethods.has(method)).length
         }
       ];
@@ -370,22 +662,6 @@ var createFactReader = (ts, ast) => {
       })) : []
     ];
   };
-  const implementsGuard = (node, guardNames) => !!node.heritageClauses?.some((clause) => clause.token === ts.SyntaxKind.ImplementsKeyword && clause.types.some(({ expression }) => guardNames.has(ast.expressionName(expression) ?? "")));
-  const guardClassIn = (node, guardNames) => {
-    if ((ts.isClassExpression(node) || ts.isClassDeclaration(node)) && implementsGuard(node, guardNames))
-      return node;
-    return ts.forEachChild(node, (child) => guardClassIn(child, guardNames)) ?? null;
-  };
-  const callsIn = (node, names) => {
-    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && names.has(node.expression.text))
-      return node.expression.text;
-    return ts.forEachChild(node, (child) => callsIn(child, names)) ?? null;
-  };
-  const scopeOf = (node) => {
-    const scope = node.members.find((member) => ts.isPropertyDeclaration(member) && ast.nodeName(member.name) === "scope" && !!ts.getModifiers(member)?.some(({ kind }) => kind === ts.SyntaxKind.StaticKeyword))?.initializer;
-    const value = scope && unwrap(scope);
-    return value && ts.isStringLiteralLike(value) ? value.text : null;
-  };
   const docOf = (source, node) => {
     const { text } = source;
     const ranges = ts.getLeadingCommentRanges(text, node.getFullStart()) ?? [];
@@ -401,108 +677,20 @@ var createFactReader = (ts, ast) => {
 `)).map((line) => line.trim().replace(/^\/\*\*?|\*\/$/g, "").replace(/^(?:\/\/[?*!]?|\*)/, "").replace(/\{@link\s+([^}\s|]+)[^}]*\}/g, "$1").trim()).filter((line) => line && !/^(?:biome-ignore|eslint-|@ts-)/.test(line));
     return lines.length ? lines.join(" ") : null;
   };
-  const functionsOf = (source) => {
-    const functions = new Map;
-    for (const statement of source.statements) {
-      if (ts.isFunctionDeclaration(statement) && statement.name && statement.body)
-        functions.set(statement.name.text, { statement, name: statement.name, body: statement.body });
-      if (!ts.isVariableStatement(statement))
-        continue;
-      for (const declaration of statement.declarationList.declarations) {
-        const initializer = declaration.initializer && unwrap(declaration.initializer);
-        if (initializer && ts.isIdentifier(declaration.name) && (ts.isArrowFunction(initializer) || ts.isFunctionExpression(initializer)))
-          functions.set(declaration.name.text, { statement, name: declaration.name, body: initializer.body });
-      }
-    }
-    return functions;
-  };
-  const guardFactoriesOf = (source, guardNames) => {
-    const functions = functionsOf(source);
-    const factories = new Map;
-    const factoryOf = (name, scope, via) => {
-      const found = functions.get(name);
-      if (!found)
-        return;
-      factories.set(name, {
-        name,
-        span: spanOf(source, found.name),
-        extent: extentOf(source, found.statement),
-        scope,
-        doc: docOf(source, found.statement),
-        via
-      });
-    };
-    for (const [name, { body }] of functions) {
-      const guard = guardClassIn(body, guardNames);
-      if (guard)
-        factoryOf(name, scopeOf(guard), null);
-    }
-    for (let isGrowing = true;isGrowing; ) {
-      isGrowing = false;
-      for (const [name, { body }] of functions) {
-        const called = factories.has(name) ? null : callsIn(body, new Set(factories.keys()));
-        if (!called)
-          continue;
-        factoryOf(name, factories.get(called)?.scope ?? null, called);
-        isGrowing = true;
-      }
-    }
-    return factories;
-  };
-  const guardsOf = (source, imports) => {
-    const guardNames = new Set([
-      "Guard",
-      ...imports.filter(({ imported }) => imported === "Guard").map(({ name }) => name)
-    ]);
-    const imported = new Set(imports.map(({ name }) => name));
-    const factories = guardFactoriesOf(source, guardNames);
-    const guards = [];
-    const calls = [];
-    for (const statement of source.statements) {
-      if (ts.isClassDeclaration(statement) && statement.name && implementsGuard(statement, guardNames))
-        guards.push({
-          name: statement.name.text,
-          span: spanOf(source, statement.name),
-          extent: extentOf(source, statement),
-          scope: scopeOf(statement),
-          doc: docOf(source, statement),
-          factory: null
-        });
-      if (!ts.isVariableStatement(statement))
-        continue;
-      for (const declaration of statement.declarationList.declarations) {
-        const initializer = declaration.initializer && unwrap(declaration.initializer);
-        if (!initializer || !ts.isIdentifier(declaration.name))
-          continue;
-        const made = {
-          name: declaration.name.text,
-          span: spanOf(source, declaration.name),
-          extent: extentOf(source, statement),
-          doc: docOf(source, statement)
-        };
-        if (ts.isClassExpression(initializer) && implementsGuard(initializer, guardNames))
-          guards.push({ ...made, scope: scopeOf(initializer), factory: null });
-        if (!ts.isCallExpression(initializer) || !ts.isIdentifier(initializer.expression))
-          continue;
-        const callee = initializer.expression.text;
-        const factory = factories.get(callee);
-        if (factory)
-          guards.push({ ...made, scope: factory.scope, factory: callee });
-        else if (imported.has(callee))
-          calls.push({ ...made, callee });
-      }
-    }
-    return { guards, guardFactories: [...factories.values()], guardCalls: calls };
-  };
+  const { guardsIn, guardsOf } = createGuardFactReader(ts, ast, { spanOf, extentOf, unwrap, docOf });
   const lowerFirst = (text) => text.charAt(0).toLowerCase() + text.slice(1);
   const importsIn = (source) => source.statements.filter(ts.isImportDeclaration).flatMap(importsOf);
   const read = (source, owner) => {
     const imports = importsIn(source);
+    const madeInPlace = [];
     const facts = {
       fileName: source.fileName,
       owner,
       imports,
-      ...guardsOf(source, imports),
+      guards: [],
+      guardFactories: [],
+      guardCalls: [],
+      guardLabels: {},
       constants: [],
       enums: [],
       filters: [],
@@ -512,6 +700,7 @@ var createFactReader = (ts, ast) => {
       endpoints: [],
       internals: [],
       adaptors: [],
+      adaptorBindings: source.text.includes("applyAdaptor") ? adaptorBindingsIn(source) : [],
       stores: []
     };
     for (const statement of source.statements) {
@@ -536,16 +725,19 @@ var createFactReader = (ts, ast) => {
           ...name,
           model: moduleRefOf(call.arguments[0], "db"),
           methods: methodsOf(source, statement),
-          plugs: plugsOf(source, builder)
+          plugs: plugsOf(source, builder),
+          fields: objectKeys(source, returnedObject(builder)).map(({ name }) => name)
         });
-      else if (callee === "slice")
+      else if (callee === "slice") {
+        const model = moduleRefOf(call.arguments[0], "srv");
+        const member = model ?? name.name;
         facts.slices.push({
           ...name,
-          model: moduleRefOf(call.arguments[0], "srv"),
-          guards: guardsIn(call.arguments.find(ts.isObjectLiteralExpression)),
-          keys: sliceKeysOf(source, builder)
+          model,
+          guards: guardsIn(source, call.arguments.find(ts.isObjectLiteralExpression), madeInPlace, member),
+          keys: sliceKeysOf(source, builder, madeInPlace, member)
         });
-      else if (callee === "internal")
+      } else if (callee === "internal")
         facts.internals.push({
           ...name,
           model: moduleRefOf(call.arguments[0], "srv"),
@@ -560,13 +752,14 @@ var createFactReader = (ts, ast) => {
           plugs: plugsOf(source, builder),
           doc: docOf(source, statement)
         });
-      } else if (callee === "endpoint")
+      } else if (callee === "endpoint") {
+        const model = moduleRefOf(call.arguments[0], "srv");
         facts.endpoints.push({
           ...name,
-          model: moduleRefOf(call.arguments[0], "srv"),
-          keys: endpointKeysOf(source, builder)
+          model,
+          keys: endpointKeysOf(source, builder, madeInPlace, model ?? name.name)
         });
-      else if (callee === "store")
+      } else if (callee === "store")
         facts.stores.push({
           ...name,
           model: moduleRefOf(call.arguments[0], "sig"),
@@ -574,10 +767,647 @@ var createFactReader = (ts, ast) => {
           actions: methodsOf(source, statement)
         });
     }
-    return facts;
-  };
-  return { read, spanOf, extentOf, docOf, importsIn, moduleRefOf, chainOf, unwrap };
-};
+    return { ...facts, ...guardsOf(source, imports, madeInPlace) };
+  };
+  return { read, spanOf, extentOf, docOf, importsIn, moduleRefOf, chainOf, unwrap };
+};
+
+// pkgs/@akanjs/language/guardResolver.ts
+var frameworkOwner = "akanjs";
+var frameworkPattern = /^akanjs(?:\/|$)/;
+var aliasPattern = /^@(apps|libs)\/([^/]+)/;
+var maxMapDepth = 4;
+var identifierPattern = /^[\p{ID_Start}$_][\p{ID_Continue}$\u200c\u200d]*$/u;
+var starExportPattern = /export\s*\*\s*from\s*["']([^"']+)["']/g;
+var exportingPatternOf = (name) => new RegExp(`export\\s*\\{(?:[^}]*?[\\s,])?${escapeRegExp(name)}(?![\\w$])`);
+var declaringPatternOf = (name, isAnyBinding) => {
+  const escaped = escapeRegExp(name);
+  const braced = "\\{(?:[^}]*?[\\s,])?";
+  const leads = [
+    "function\\s*\\*?\\s*",
+    "(?:const|let|var)\\s+",
+    `export\\s*${braced}`,
+    ...isAnyBinding ? ["class\\s+", `(?:const|let|var)\\s*${braced}`] : []
+  ];
+  return new RegExp(`(?:${leads.join("|")})${escaped}(?![\\w$])|,\\s*${escaped}\\s*(?::[^=;,]+)?=(?![=>])`);
+};
+
+class GuardResolver {
+  #source;
+  #routes;
+  #guards = new Map;
+  #madeInPlace = new Map;
+  #mapEntries = new Map;
+  #reexports = new Map;
+  #declarations = new Map;
+  #starExports = new Map;
+  #moduleExports = new Map;
+  #ownerFiles = null;
+  #modules = null;
+  constructor(source, routes) {
+    this.#source = source;
+    this.#routes = routes;
+  }
+  find(local, site) {
+    return this.#findGuard(local, site, 0);
+  }
+  madeInPlace(fileName, name) {
+    return this.#madeInPlace.get(`${fileName}
+${name}`);
+  }
+  declare(facts) {
+    const factories = new Map;
+    const declaredFactories = [];
+    for (const file of facts)
+      for (const fact of file.guardFactories) {
+        const factory = {
+          fact,
+          owner: file.owner,
+          site: file,
+          made: [],
+          isReal: fact.direct,
+          scope: fact.scope,
+          layers: fact.layers,
+          targets: []
+        };
+        factories.set(fact.name, [...factories.get(fact.name) ?? [], factory]);
+        declaredFactories.push(factory);
+      }
+    for (const factory of declaredFactories)
+      factory.targets = factory.fact.via.flatMap(({ callee, layers }) => {
+        const target = this.#factoryAt(factories, callee, factory.site);
+        return target ? [{ target, layers }] : [];
+      });
+    for (let isGrowing = true;isGrowing; ) {
+      isGrowing = false;
+      for (const factory of declaredFactories) {
+        const via = factory.targets.find(({ target, layers }) => target.isReal && target.layers >= layers);
+        if (factory.isReal || !via)
+          continue;
+        factory.isReal = true;
+        factory.layers = factory.fact.layers + via.target.layers - via.layers;
+        factory.scope ??= via.target.scope;
+        isGrowing = true;
+      }
+    }
+    const partsOf = (factory, seen = new Set) => {
+      if (seen.has(factory))
+        return [];
+      seen.add(factory);
+      return [
+        { fileName: factory.site.fileName, extent: factory.fact.extent },
+        ...factory.targets.filter(({ target }) => target.isReal).flatMap(({ target }) => partsOf(target, seen))
+      ];
+    };
+    const declare = (file, made, scope, parts) => {
+      const { name, span, extent, doc } = made;
+      const label = file.guardLabels[name];
+      const own = { fileName: file.fileName, extent };
+      const guard = { name, owner: file.owner, span, scope, doc, parts: [own, ...parts], file: null, label };
+      if (name.includes("@"))
+        this.#madeInPlace.set(`${file.fileName}
+${name}`, guard);
+      else
+        this.#guards.set(name, [...this.#guards.get(name) ?? [], guard]);
+      return guard;
+    };
+    const extending = [];
+    for (const file of facts) {
+      for (const made of file.guards) {
+        const factory = made.factory ? factories.get(made.factory)?.find((other) => other.site.fileName === file.fileName) : undefined;
+        if (!made.factory)
+          declare(file, made, made.scope, []);
+        else if (factory?.isReal && factory.layers === made.layers)
+          factory.made.push(declare(file, made, factory.scope, partsOf(factory)));
+      }
+      for (const made of file.guardCalls) {
+        if (made.kind === "extends") {
+          extending.push([file, made]);
+          continue;
+        }
+        const factory = this.#factoryAt(factories, made.callee, file);
+        if (factory?.isReal && factory.layers === made.layers)
+          factory.made.push(declare(file, made, factory.scope, partsOf(factory)));
+      }
+    }
+    for (let isGrowing = true;isGrowing; ) {
+      isGrowing = false;
+      for (const [idx, entry] of extending.entries()) {
+        const [file, made] = entry;
+        const found = this.#findGuard(made.callee, file, 0, true);
+        if (!("guard" in found))
+          continue;
+        declare(file, made, made.scope ?? found.guard.scope, found.guard.parts);
+        extending.splice(idx, 1);
+        isGrowing = true;
+        break;
+      }
+    }
+    for (const { fact, made, isReal } of declaredFactories)
+      if (isReal && made.every((guard) => !guard.doc))
+        for (const guard of made)
+          guard.doc = fact.doc;
+    for (const list of this.#guards.values())
+      for (const guard of list)
+        if (list.some((other) => other !== guard && other.owner === guard.owner))
+          guard.file = this.inOwner(guard.span.fileName, guard.owner);
+    for (const guard of this.#madeInPlace.values())
+      guard.file = this.inOwner(guard.span.fileName, guard.owner);
+    return [...[...this.#guards.values()].flat(), ...this.#madeInPlace.values()];
+  }
+  #factoryAt(factories, callee, site, depth = 0) {
+    const [head = callee, member] = callee.split(".");
+    const imported = site.imports.find((item) => item.name === head);
+    if (!imported)
+      return member ? undefined : factories.get(callee)?.find((other) => other.site.fileName === site.fileName);
+    if (member && imported.imported !== "*")
+      return;
+    const from = this.ownerOfSpecifier(site.fileName, imported.from);
+    if (from === undefined || from === frameworkOwner)
+      return;
+    const name = member ?? (imported.imported === "default" || imported.imported === "*" ? head : imported.imported);
+    const candidates = factories.get(name) ?? [];
+    const near = this.pathOfSpecifier(site.fileName, imported.from);
+    const own = this.#nearest(candidates.filter((other) => other.owner === from), ({ site }) => site.fileName, near);
+    if (own)
+      return own;
+    const reexport = from && depth < maxMapDepth ? this.reexportOf(from, name, near) : null;
+    if (reexport)
+      return this.#factoryAt(factories, reexport.local, reexport.site, depth + 1);
+    return from && near ? this.#throughStar(candidates, from, name, near) : undefined;
+  }
+  #findGuard(local, site, depth, isBase = false) {
+    const segments = local.split(".");
+    const head = segments[0] ?? local;
+    const imported = site.imports.find((item) => item.name === head);
+    const from = imported ? this.ownerOfSpecifier(site.fileName, imported.from) : undefined;
+    if (imported && from === undefined)
+      return { external: true };
+    const near = imported ? this.pathOfSpecifier(site.fileName, imported.from) : this.#source.relative(site.fileName).replace(/\.tsx?$/, "");
+    const named = imported && imported.imported !== "default" && imported.imported !== "*" ? imported.imported : null;
+    const path = imported?.imported === "*" ? segments.slice(1) : [named ?? head, ...segments.slice(1)];
+    const holder = imported ? from ?? null : site.owner;
+    const [objectName, member] = path;
+    if (path.length === 2 && objectName && member && holder !== frameworkOwner && depth < maxMapDepth) {
+      const made = this.#nearest((this.#guards.get(`${objectName}.${member}`) ?? []).filter((guard) => guard.owner === holder), ({ span }) => span.fileName, near);
+      if (made)
+        return { guard: made };
+      for (const entry of this.#mapEntriesOf(objectName, member, imported ? null : site.fileName, holder)) {
+        const found = this.#findGuard(entry.name, entry.site, depth + 1, isBase);
+        if ("guard" in found)
+          return found;
+      }
+    }
+    const name = path[path.length - 1] ?? head;
+    if (from === frameworkOwner)
+      return { name, from };
+    const declared = this.#guards.get(name) ?? [];
+    const own = this.#nearest(declared.filter((other) => other.owner === (imported ? from : site.owner)), ({ span }) => span.fileName, near);
+    if (own)
+      return { guard: own };
+    if (!imported) {
+      const visible = isBase ? undefined : declared.find((other) => this.visible(other.owner, site.owner));
+      return visible ? { guard: visible } : { name, from };
+    }
+    const reexport = from && depth < maxMapDepth ? this.reexportOf(from, name, near) : null;
+    if (reexport)
+      return this.#findGuard(reexport.local, reexport.site, depth + 1, isBase);
+    const reached = from && near ? this.#throughStar(declared, from, name, near) : undefined;
+    return reached ? { guard: reached } : { name, from };
+  }
+  reexportOf(owner, name, near) {
+    const key = `${owner}
+${name}
+${near ?? ""}`;
+    const cached = this.#reexports.get(key);
+    if (cached !== undefined)
+      return cached;
+    let found = null;
+    const exporting = exportingPatternOf(name);
+    for (const fileName of this.#filesOf(owner, name, near)) {
+      const text = this.#source.readText(fileName);
+      if (text === undefined || !exporting.test(text))
+        continue;
+      const reexport = this.#reexportIn(this.#source.parse(fileName, text), name);
+      if (!reexport)
+        continue;
+      const site = { fileName, owner, imports: [] };
+      found = reexport.from ? {
+        local: reexport.name,
+        site: { ...site, imports: [{ ...reexport, imported: reexport.name, from: reexport.from }] }
+      } : { local: reexport.name, site };
+      break;
+    }
+    this.#reexports.set(key, found);
+    return found;
+  }
+  #reexportIn(source, name) {
+    const { ts, reader } = this.#source;
+    for (const statement of source.statements) {
+      if (!ts.isExportDeclaration(statement) || statement.isTypeOnly)
+        continue;
+      const { exportClause, moduleSpecifier } = statement;
+      if (!exportClause || !ts.isNamedExports(exportClause))
+        continue;
+      const element = exportClause.elements.find((item) => !item.isTypeOnly && item.name.text === name);
+      if (!element)
+        continue;
+      const original = (element.propertyName ?? element.name).text;
+      if (moduleSpecifier && ts.isStringLiteral(moduleSpecifier))
+        return { name: original, from: moduleSpecifier.text };
+      const imported = reader.importsIn(source).find((item) => item.name === original);
+      if (!imported)
+        return { name: original, from: null };
+      return imported.imported === "default" || imported.imported === "*" ? null : { name: imported.imported, from: imported.from };
+    }
+    return null;
+  }
+  #filesOf(owner, name, near) {
+    const isNear = (fileName) => {
+      const relative = this.#source.relative(fileName);
+      return !!near && (relative.startsWith(`${near}/`) || relative.replace(/\.tsx?$/, "") === near);
+    };
+    if (!identifierPattern.test(name))
+      return [];
+    const candidates = this.#filesIn(owner).filter(([, words]) => words.includes(`
+${name}
+`)).map(([fileName]) => fileName);
+    return [...candidates.filter(isNear), ...candidates.filter((other) => !isNear(other))];
+  }
+  #mapEntriesOf(objectName, member, fileName, owner) {
+    const key = `${objectName}
+${member}
+${fileName ?? ""}
+${owner ?? ""}`;
+    const cached = this.#mapEntries.get(key);
+    if (cached)
+      return cached;
+    const { ts, reader } = this.#source;
+    const entries = [];
+    const fileNames = [
+      ...fileName ? [fileName] : [],
+      ...(owner === null ? [] : this.#filesIn(owner)).filter(([other, words]) => other !== fileName && words.includes(`
+${objectName}
+`) && words.includes(`
+${member}
+`)).map(([other]) => other)
+    ];
+    for (const holder of fileNames) {
+      const text = this.#source.readText(holder);
+      if (text === undefined)
+        continue;
+      const source = this.#source.parse(holder, text);
+      const site = { fileName: holder, owner: this.#source.ownerOf(holder), imports: reader.importsIn(source) };
+      for (const statement of source.statements) {
+        if (!ts.isVariableStatement(statement))
+          continue;
+        const map = statement.declarationList.declarations.find((declaration) => ts.isIdentifier(declaration.name) && declaration.name.text === objectName)?.initializer;
+        const object = map && reader.unwrap(map);
+        if (!object || !ts.isObjectLiteralExpression(object))
+          continue;
+        for (const property of object.properties) {
+          if (ts.isShorthandPropertyAssignment(property) && property.name.text === member)
+            entries.push({ name: member, site });
+          if (!ts.isPropertyAssignment(property) || !(ts.isIdentifier(property.name) || ts.isStringLiteral(property.name)) || property.name.text !== member)
+            continue;
+          const value = reader.unwrap(property.initializer);
+          if (ts.isIdentifier(value))
+            entries.push({ name: value.text, site });
+          else if (ts.isPropertyAccessExpression(value) && ts.isIdentifier(value.expression))
+            entries.push({ name: `${value.expression.text}.${value.name.text}`, site });
+        }
+      }
+    }
+    this.#mapEntries.set(key, entries);
+    return entries;
+  }
+  declarationOf(owner, name, near, depth = 0) {
+    const key = `${owner}
+${name}
+${near ?? ""}`;
+    const cached = this.#declarations.get(key);
+    if (cached !== undefined)
+      return cached;
+    this.#declarations.set(key, null);
+    const declaring = declaringPatternOf(name, false);
+    let found = null;
+    for (const fileName of this.#filesOf(owner, name, near)) {
+      const text = this.#source.readText(fileName);
+      if (text === undefined || !declaring.test(text))
+        continue;
+      const source = this.#source.parse(fileName, text);
+      const declared = this.#routes.declarationIn(source, name);
+      if (declared) {
+        found = { source, ...declared, name };
+        break;
+      }
+      const reexport = this.#reexportIn(source, name);
+      if (!reexport)
+        continue;
+      if (!reexport.from) {
+        const local = this.#routes.declarationIn(source, reexport.name);
+        found = local ? { source, ...local, name: reexport.name } : null;
+        break;
+      }
+      const next = this.ownerOfSpecifier(fileName, reexport.from);
+      if (next && next !== frameworkOwner && depth < maxMapDepth)
+        found = this.declarationOf(next, reexport.name, this.pathOfSpecifier(fileName, reexport.from), depth + 1);
+      break;
+    }
+    this.#declarations.set(key, found);
+    return found;
+  }
+  #throughStar(declared, owner, name, near) {
+    if (!declared.length)
+      return;
+    const { owners, isOpaque } = this.starExportsOf(owner, near);
+    const reached = declared.filter((other) => other.owner !== null && owners.includes(other.owner));
+    return reached.length === 1 && !isOpaque && !this.declares(owner, name) ? reached[0] : undefined;
+  }
+  starExportsOf(owner, near) {
+    const key = `${owner}
+${near}`;
+    const cached = this.#starExports.get(key);
+    if (cached)
+      return cached;
+    const found = { owners: [], packages: [], paths: [near], isOpaque: false };
+    this.#starExports.set(key, found);
+    for (let idx = 0;idx < found.paths.length; idx++)
+      for (const fileName of this.#modulesAt(found.paths[idx] ?? ""))
+        for (const [, specifier = ""] of this.#source.readText(fileName)?.matchAll(starExportPattern) ?? []) {
+          const target = this.ownerOfSpecifier(fileName, specifier);
+          const path = this.pathOfSpecifier(fileName, specifier);
+          if (path === null && !found.packages.includes(specifier))
+            found.packages.push(specifier);
+          if (target === undefined || target === frameworkOwner || path === null)
+            found.isOpaque = true;
+          else if (!found.paths.includes(path))
+            found.paths.push(path);
+          if (target && target !== frameworkOwner && target !== owner && !found.owners.includes(target))
+            found.owners.push(target);
+        }
+    return found;
+  }
+  exportsAt(path, name) {
+    const key = `${path}
+${name}`;
+    const cached = this.#moduleExports.get(key);
+    if (cached)
+      return cached;
+    const found = { named: null, stars: [] };
+    const exporting = exportingPatternOf(name);
+    for (const fileName of this.#modulesAt(path)) {
+      const text = this.#source.readText(fileName);
+      if (text === undefined)
+        continue;
+      const named = identifierPattern.test(name) && exporting.test(text) ? this.#reexportIn(this.#source.parse(fileName, text), name) : null;
+      if (named) {
+        found.named = { ...named, fileName };
+        found.stars = [];
+        break;
+      }
+      for (const [, specifier = ""] of text.matchAll(starExportPattern)) {
+        const target = this.pathOfSpecifier(fileName, specifier);
+        if (target !== null && !found.stars.includes(target))
+          found.stars.push(target);
+      }
+    }
+    this.#moduleExports.set(key, found);
+    return found;
+  }
+  #modulesAt(path) {
+    if (!this.#modules) {
+      this.#modules = new Map;
+      for (const [fileName] of this.#source.files) {
+        const module = this.#source.relative(fileName).replace(/\.tsx?$/, "");
+        for (const key of module.endsWith("/index") ? [module, module.slice(0, -6)] : [module])
+          this.#modules.set(key, [...this.#modules.get(key) ?? [], fileName]);
+      }
+    }
+    return this.#modules.get(path) ?? [];
+  }
+  hasModule(path) {
+    return this.#modulesAt(path).length > 0;
+  }
+  packagesUnder(owner, folder) {
+    const packages = new Set;
+    for (const [fileName, words] of this.#filesIn(owner)) {
+      if (!this.#source.relative(fileName).startsWith(`${folder}/`) || !words.includes(`
+export
+`))
+        continue;
+      for (const [, specifier = ""] of this.#source.readText(fileName)?.matchAll(starExportPattern) ?? [])
+        if (this.pathOfSpecifier(fileName, specifier) === null)
+          packages.add(specifier);
+    }
+    return [...packages];
+  }
+  declares(owner, name) {
+    const declaring = declaringPatternOf(name, true);
+    return this.#filesOf(owner, name, null).some((fileName) => declaring.test(this.#source.readText(fileName) ?? ""));
+  }
+  declaresAt(path, name) {
+    const declaring = declaringPatternOf(name, true);
+    return this.#modulesAt(path).some((fileName) => declaring.test(this.#source.readText(fileName) ?? ""));
+  }
+  #filesIn(owner) {
+    if (!this.#ownerFiles) {
+      this.#ownerFiles = new Map;
+      for (const entry of this.#source.files) {
+        const fileOwner = testFilePattern.test(entry[0]) ? null : this.#source.ownerOf(entry[0]);
+        const files = fileOwner === null ? null : this.#ownerFiles.get(fileOwner);
+        if (files)
+          files.push(entry);
+        else if (fileOwner !== null)
+          this.#ownerFiles.set(fileOwner, [entry]);
+      }
+    }
+    return this.#ownerFiles.get(owner) ?? [];
+  }
+  #nearest(items, fileOf, near) {
+    const isNear = (fileName) => {
+      const relative = this.#source.relative(fileName);
+      return !!near && (relative.startsWith(`${near}/`) || relative.replace(/\.tsx?$/, "") === near);
+    };
+    return items.find((item) => isNear(fileOf(item))) ?? items[0];
+  }
+  inOwner(fileName, owner) {
+    const relative = this.#source.relative(fileName);
+    return owner && relative.startsWith(`${owner}/`) ? relative.slice(owner.length + 1) : relative;
+  }
+  ownerOfSpecifier(fileName, specifier) {
+    if (frameworkPattern.test(specifier))
+      return frameworkOwner;
+    const path = this.pathOfSpecifier(fileName, specifier);
+    return path === null ? undefined : ownerOf(path) ?? undefined;
+  }
+  pathOfSpecifier(fileName, specifier) {
+    const alias = specifier.match(aliasPattern);
+    if (alias)
+      return `${alias[1]}/${alias[2]}${specifier.slice(alias[0].length)}`;
+    if (!specifier.startsWith("."))
+      return null;
+    const segments = this.#source.relative(fileName).split("/").slice(0, -1);
+    for (const segment of specifier.split("/"))
+      if (segment === "..")
+        segments.pop();
+      else if (segment !== ".")
+        segments.push(segment);
+    return segments.join("/");
+  }
+  visible(target, from) {
+    return !from || !target || target === from || target.startsWith("libs/");
+  }
+}
+
+// pkgs/@akanjs/language/adaptorResolver.ts
+var maxModules = 64;
+
+class AdaptorResolver {
+  #source;
+  #resolver;
+  #sink;
+  #adaptors = new Map;
+  #plugs = new Map;
+  #serviceFields = new Set;
+  constructor(source, resolver, sink) {
+    this.#source = source;
+    this.#resolver = resolver;
+    this.#sink = sink;
+  }
+  declare(facts) {
+    const counts = new Map;
+    for (const file of facts)
+      for (const fact of file.adaptors) {
+        const key = this.#sink.key("adaptor", file.owner, fact.name);
+        counts.set(key, (counts.get(key) ?? 0) + 1);
+      }
+    const declared = facts.flatMap((file) => file.adaptors.map((fact) => {
+      const key = this.#sink.key("adaptor", file.owner, fact.name);
+      const id = (counts.get(key) ?? 0) > 1 ? this.#sink.key("adaptor", file.owner, `${this.#resolver.inOwner(file.fileName, file.owner)}#${fact.name}`) : key;
+      const adaptor = { fact, owner: file.owner, fileName: file.fileName, id };
+      this.#adaptors.set(fact.name, [...this.#adaptors.get(fact.name) ?? [], adaptor]);
+      this.#nodeOf(adaptor);
+      return { adaptor, file };
+    }));
+    for (const { adaptor, file } of declared)
+      for (const plug of adaptor.fact.plugs)
+        this.#sink.addEdge(adaptor.id, this.#idOf(plug.target, file), "plugs", plug.name, this.#sink.location(plug.span));
+    for (const file of facts)
+      for (const binding of file.adaptorBindings)
+        this.#sink.addEdge(this.#idOf(binding.role, file), this.#idOf(binding.adaptor, file), "binds", file.owner, this.#sink.location(binding.span));
+  }
+  addService(refName, service, file) {
+    for (const plug of service.plugs) {
+      const key = `${refName}
+${plug.name}`;
+      this.#plugs.set(key, [
+        ...this.#plugs.get(key) ?? [],
+        { owner: file.owner, target: this.#idOf(plug.target, file) }
+      ]);
+    }
+    for (const field of service.fields)
+      this.#serviceFields.add(`${file.owner ?? ""}
+${refName}
+${field}`);
+  }
+  pluggedOf(owner, module, field) {
+    const plugs = this.#plugs.get(`${module}
+${field}`) ?? [];
+    const own = plugs.filter((plug) => plug.owner === owner);
+    if (!own.length && this.#serviceFields.has(`${owner ?? ""}
+${module}
+${field}`))
+      return [];
+    const inherited = own.length ? own : plugs.filter((plug) => this.#resolver.visible(plug.owner, owner));
+    return [...new Set(inherited.map(({ target }) => target))];
+  }
+  #idOf(local, file) {
+    const [head, member] = local.split(".");
+    const imported = file.imports.find((item) => item.name === head);
+    const name = member ?? (imported && imported.imported !== "default" && imported.imported !== "*" ? imported.imported : head);
+    const path = imported ? this.#resolver.pathOfSpecifier(file.fileName, imported.from) : null;
+    if (imported && path === null && !frameworkPattern.test(imported.from))
+      return this.#packageAdaptorOf(name, imported.from);
+    const from = imported ? this.#resolver.ownerOfSpecifier(file.fileName, imported.from) : undefined;
+    const declared = this.#adaptors.get(name) ?? [];
+    const holder = from === undefined ? file.owner : from;
+    const own = this.#adaptorIn(name, declared, holder, path, file.fileName);
+    if (own && "from" in own)
+      return this.#packageAdaptorOf(own.name, own.from);
+    const found = own === undefined && from !== frameworkOwner ? declared.find((adaptor) => this.#resolver.visible(adaptor.owner, holder)) : own;
+    if (found)
+      return found.id;
+    const reexported = own === undefined && from && from !== frameworkOwner ? this.#packageShimOf(from, name, path) : null;
+    if (reexported)
+      return this.#packageAdaptorOf(reexported.name, reexported.from);
+    const owner = from === frameworkOwner ? null : imported ? from ?? null : file.owner;
+    const detail = from === frameworkOwner ? [frameworkOwner] : [];
+    return this.#sink.addNode(this.#sink.key("adaptor", owner, name), "adaptor", owner, name, null, detail).id;
+  }
+  #adaptorIn(name, declared, owner, path, fileName) {
+    const own = declared.filter((adaptor) => adaptor.owner === owner);
+    const [first] = own;
+    if (path === null)
+      return own.find((adaptor) => adaptor.fileName === fileName) ?? first;
+    if (own.length === 1)
+      return first;
+    if (!this.#resolver.hasModule(path))
+      return own.find((adaptor) => this.#source.relative(adaptor.fileName).startsWith(`${path}/`)) ?? first;
+    const exported = this.#exportedAt(name, path, new Set).filter((item) => first || ("fact" in item));
+    const [only] = exported;
+    if (only)
+      return exported.length === 1 ? only : null;
+    return first ? null : undefined;
+  }
+  #exportedAt(name, path, seen) {
+    const key = `${path}
+${name}`;
+    if (seen.has(key) || seen.size >= maxModules)
+      return [];
+    seen.add(key);
+    const here = (this.#adaptors.get(name) ?? []).filter((adaptor) => {
+      const module = this.#source.relative(adaptor.fileName).replace(/\.tsx?$/, "");
+      return module === path || module === `${path}/index`;
+    });
+    if (here.length)
+      return here;
+    const { named, stars } = this.#resolver.exportsAt(path, name);
+    if (named?.from && this.#resolver.pathOfSpecifier(named.fileName, named.from) === null)
+      return [{ name: named.name === "default" ? name : named.name, from: named.from }];
+    if (named) {
+      const target = named.from === null ? path : this.#resolver.pathOfSpecifier(named.fileName, named.from);
+      return target === null ? [] : this.#exportedAt(named.name, target, seen);
+    }
+    return [...new Set(stars.flatMap((star) => this.#exportedAt(name, star, seen)))];
+  }
+  #packageAdaptorOf(name, specifier) {
+    if (frameworkPattern.test(specifier))
+      return this.#sink.addNode(this.#sink.key("adaptor", null, name), "adaptor", null, name, null, [frameworkOwner]).id;
+    const pkg = specifier.split("/").slice(0, specifier.startsWith("@") ? 2 : 1).join("/");
+    return this.#sink.addNode(this.#sink.key("adaptor", pkg, name), "adaptor", null, name, null, [pkg]).id;
+  }
+  #packageShimOf(owner, name, near) {
+    const reexport = this.#resolver.reexportOf(owner, name, near);
+    const [shim] = reexport?.site.imports ?? [];
+    if (reexport && shim && this.#resolver.pathOfSpecifier(reexport.site.fileName, shim.from) === null)
+      return { name: reexport.local === "default" ? name : reexport.local, from: shim.from };
+    if (reexport || !near)
+      return null;
+    const { packages, paths } = this.#resolver.hasModule(near) ? this.#resolver.starExportsOf(owner, near) : { packages: this.#resolver.packagesUnder(owner, near), paths: [] };
+    const [only] = packages;
+    const isDeclared = this.#resolver.declares(owner, name) || paths.some((path) => this.#resolver.declaresAt(path, name));
+    return packages.length === 1 && only && !isDeclared ? { name, from: only } : null;
+  }
+  #nodeOf({ fact, owner, fileName, id }) {
+    const detail = fact.refName ? [fact.refName] : [];
+    const node = this.#sink.addNode(id, "adaptor", owner, fact.name, fact.span, detail);
+    if (fact.doc && !node.doc)
+      node.doc = fact.doc;
+    this.#sink.digest(node, this.#source.readText(fileName), fact.extent);
+    return node.id;
+  }
+}
 
 // pkgs/akanjs/common/trimSlashes.ts
 var trimTrailingSlashes = (value) => {
@@ -611,7 +1441,8 @@ var ROOT_LAYOUT_ROUTE_EXPORTS = new Set([
   "wsConnect",
   "layoutStyle",
   "viewport",
-  "McpAppRoot"
+  "McpAppRoot",
+  "LevelBoundary"
 ]);
 var RESERVED_ROUTE_CONFIG_EXPORTS = new Set([...ROOT_LAYOUT_ROUTE_EXPORTS].filter((name) => name !== "default" && !/^[A-Z]/.test(name)));
 function parseRouteModuleKey(key) {
@@ -726,24 +1557,23 @@ rootLayout
   }
   declarationIn(source, name) {
     const ts = this.#ts;
+    const overloads = source.statements.filter((statement) => ts.isFunctionDeclaration(statement) && statement.name?.text === name);
+    const [first] = overloads;
+    const last = overloads.at(-1);
+    if (first?.name && last)
+      return { statement: first, declared: first.name, extent: { start: first.getStart(source), end: last.getEnd() } };
     for (const statement of source.statements) {
-      if (ts.isFunctionDeclaration(statement) && statement.name?.text === name)
-        return { statement, declared: statement.name, initializer: null };
       if (!ts.isVariableStatement(statement))
         continue;
       const declaration = statement.declarationList.declarations.find((item) => ts.isIdentifier(item.name) && item.name.text === name);
       if (declaration)
-        return { statement, declared: declaration.name, initializer: declaration.initializer ?? null };
+        return { statement, declared: declaration.name, extent: this.#reader.extentOf(source, statement) };
     }
     return null;
   }
   #guardOf(source, exported) {
     const ts = this.#ts;
     let current = ts.isExportAssignment(exported) ? this.#reader.unwrap(exported.expression) : null;
-    if (current && ts.isIdentifier(current)) {
-      const initializer = this.declarationIn(source, current.text)?.initializer;
-      current = initializer ? this.#reader.unwrap(initializer) : null;
-    }
     while (current && ts.isCallExpression(current) && ts.isPropertyAccessExpression(current.expression)) {
       const { name, expression } = current.expression;
       const [stage] = current.arguments;
@@ -755,9 +1585,20 @@ rootLayout
   }
   #callsIn(source, stage) {
     const ts = this.#ts;
-    const imported = new Set(this.#reader.importsIn(source).filter(({ from }) => RouteFactReader.#workspacePattern.test(from)).map(({ name }) => name));
+    const imports = this.#reader.importsIn(source).filter(({ from }) => RouteFactReader.#workspacePattern.test(from));
+    const imported = new Set(imports.filter(({ imported }) => imported !== "*").map(({ name }) => name));
+    const namespaces = new Set(imports.filter(({ imported }) => imported === "*").map(({ name }) => name));
     const calls = new Map;
-    const callOf = (name) => {
+    const callOf = (callee, shadowed) => {
+      if (ts.isPropertyAccessExpression(callee) && ts.isIdentifier(callee.expression) && namespaces.has(callee.expression.text) && !shadowed.has(callee.expression.text)) {
+        const name = `${callee.expression.text}.${callee.name.text}`;
+        if (!calls.has(name))
+          calls.set(name, { name, local: null });
+        return true;
+      }
+      if (!ts.isIdentifier(callee) || shadowed.has(callee.text))
+        return false;
+      const name = callee.text;
       if (calls.has(name))
         return true;
       const declared = this.declarationIn(source, name);
@@ -767,23 +1608,71 @@ rootLayout
         name,
         local: declared && {
           span: this.#reader.spanOf(source, declared.declared),
-          extent: this.#reader.extentOf(source, declared.statement),
+          extent: declared.extent,
           doc: this.#reader.docOf(source, declared.statement)
         }
       });
       return true;
     };
-    const visit = (node) => {
-      if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && callOf(node.expression.text))
+    const visit = (node, outer) => {
+      const shadowed = this.#scopeOf(node, outer);
+      if (ts.isCallExpression(node) && callOf(node.expression, shadowed))
         return;
-      ts.forEachChild(node, visit);
+      ts.forEachChild(node, (child) => visit(child, shadowed));
     };
     if (ts.isIdentifier(stage))
-      callOf(stage.text);
+      callOf(stage, new Set);
     else
-      visit(stage);
+      visit(stage, new Set);
     return [...calls.values()];
   }
+  #scopeOf(node, outer) {
+    const ts = this.#ts;
+    const names = [];
+    const bind = (name) => {
+      if (ts.isIdentifier(name))
+        names.push(name.text);
+      else
+        for (const element of name.elements)
+          if (!ts.isOmittedExpression(element))
+            bind(element.name);
+    };
+    const declare = (statement) => {
+      if (ts.isVariableStatement(statement))
+        for (const declaration of statement.declarationList.declarations)
+          bind(declaration.name);
+      else if ((ts.isFunctionDeclaration(statement) || ts.isClassDeclaration(statement)) && statement.name)
+        names.push(statement.name.text);
+    };
+    const hoist = (child) => {
+      if (ts.isFunctionLike(child) || ts.isClassLike(child))
+        return;
+      if (ts.isVariableDeclarationList(child) && !(child.flags & ts.NodeFlags.BlockScoped))
+        for (const declaration of child.declarations)
+          bind(declaration.name);
+      ts.forEachChild(child, hoist);
+    };
+    if (ts.isFunctionLike(node)) {
+      for (const parameter of node.parameters)
+        bind(parameter.name);
+      if (ts.isFunctionExpression(node) && node.name)
+        names.push(node.name.text);
+      if ("body" in node && node.body)
+        ts.forEachChild(node.body, hoist);
+    } else if (ts.isClassExpression(node) && node.name)
+      names.push(node.name.text);
+    else if (ts.isBlock(node))
+      node.statements.forEach(declare);
+    else if (ts.isCaseBlock(node))
+      for (const clause of node.clauses)
+        clause.statements.forEach(declare);
+    else if (ts.isCatchClause(node) && node.variableDeclaration)
+      bind(node.variableDeclaration.name);
+    else if ((ts.isForStatement(node) || ts.isForInStatement(node) || ts.isForOfStatement(node)) && node.initializer && ts.isVariableDeclarationList(node.initializer))
+      for (const declaration of node.initializer.declarations)
+        bind(declaration.name);
+    return names.length ? new Set([...outer, ...names]) : outer;
+  }
 }
 
 // pkgs/@akanjs/language/akanGraph.ts
@@ -799,10 +1688,6 @@ var builtinGuards = {
   Public: { scope: "account", doc: "Passes every caller, signed in or not." },
   None: { scope: "account", doc: "Refuses every caller." }
 };
-var frameworkOwner = "akanjs";
-var frameworkPattern = /^akanjs(?:\/|$)/;
-var aliasPattern = /^@(apps|libs)\/([^/]+)/;
-var maxMapDepth = 4;
 
 class GraphBuilder {
   #source;
@@ -810,16 +1695,21 @@ class GraphBuilder {
   #edges = new Map;
   #contexts = new Map;
   #members = new Map;
-  #guards = new Map;
-  #mapEntries = new Map;
   #routeFiles = new Map;
-  #declarations = new Map;
   #routes;
-  #adaptors = new Map;
-  #plugs = new Map;
+  #resolver;
+  #adaptors;
   constructor(source) {
     this.#source = source;
     this.#routes = new RouteFactReader(source.ts, source.reader, source.parse);
+    this.#resolver = new GuardResolver(source, this.#routes);
+    this.#adaptors = new AdaptorResolver(source, this.#resolver, {
+      key: (kind, owner, scope) => this.#key(kind, owner, scope),
+      addNode: (id, kind, owner, name, span, detail) => this.#addNode(id, kind, owner, null, name, span, detail),
+      addEdge: (from, to, kind, label, at) => this.#addEdge(from, to, kind, label, at),
+      digest: (node, text, extent) => this.#digest(node, text, extent),
+      location: (span) => this.#location(span)
+    });
   }
   build() {
     const { facts } = this.#source;
@@ -831,17 +1721,9 @@ class GraphBuilder {
       ...[...constantsByOwner].filter(([key]) => key !== owner && key?.startsWith("libs/")).flatMap(([, list]) => list)
     ];
     const typed = [];
-    for (const file of facts)
-      for (const fact of file.adaptors) {
-        const declared = { fact, owner: file.owner, fileName: file.fileName };
-        this.#adaptors.set(fact.name, [...this.#adaptors.get(fact.name) ?? [], declared]);
-        this.#adaptorNodeOf(declared);
-      }
-    for (const file of facts)
-      for (const fact of file.adaptors)
-        for (const plug of fact.plugs)
-          this.#addEdge(this.#key("adaptor", file.owner, fact.name), this.#adaptorIdOf(plug.target, file), "plugs", plug.name, this.#location(plug.span));
-    this.#declareGuards(facts);
+    this.#adaptors.declare(facts);
+    for (const guard of this.#resolver.declare(facts))
+      this.#guardNodeOf(guard);
     for (const file of facts) {
       const { owner } = file;
       const scalar = this.#source.relative(file.fileName).match(scalarPattern)?.[1];
@@ -872,10 +1754,7 @@ class GraphBuilder {
         }
         for (const method of service.methods)
           this.#addMember("method", owner, refName, method, `${service.name}.${method.name}`, file.fileName);
-        for (const plug of service.plugs)
-          this.#plugs.set(`${owner ?? ""}
-${refName}
-${plug.name}`, this.#adaptorIdOf(plug.target, file));
+        this.#adaptors.addService(refName, service, file);
       }
       for (const filter of file.filters) {
         if (!filter.name.endsWith("Filter"))
@@ -885,31 +1764,7 @@ ${plug.name}`, this.#adaptorIdOf(plug.target, file));
         for (const query of filter.queries)
           this.#digest(this.#addNode(this.#key("query", owner, refName, query.name), "query", owner, refName, query.name, query.span), this.#source.readText(file.fileName), query.extent);
       }
-      for (const slice of file.slices) {
-        const refName = slice.model;
-        if (!refName)
-          continue;
-        const fallback = this.#addNode(this.#key("slice", owner, refName), "slice", owner, refName, "", slice.span, slice.guards);
-        for (const guard of slice.guards)
-          this.#guard(fallback, guard, file);
-        for (const key of slice.keys) {
-          const detail = [...key.guards, ...key.live ? ["live"] : []];
-          const node = this.#addMember("slice", owner, refName, key, `${refName}.${key.name}`, file.fileName, detail);
-          for (const guard of key.guards)
-            this.#guard(node, guard, file);
-        }
-      }
-      for (const endpoint of file.endpoints) {
-        const refName = endpoint.model;
-        if (!refName)
-          continue;
-        for (const key of endpoint.keys) {
-          const detail = [...key.verb ? [key.verb] : [], ...key.guards];
-          const node = this.#addMember("endpoint", owner, refName, key, `${refName}.${key.name}`, file.fileName, detail);
-          for (const guard of key.guards)
-            this.#guard(node, guard, file);
-        }
-      }
+      this.#addGuarded(file);
       for (const internal of file.internals)
         for (const key of internal.keys)
           if (internal.model && key.type !== "resolveField")
@@ -925,7 +1780,7 @@ ${plug.name}`, this.#adaptorIdOf(plug.target, file));
         types.set(node.label, [...types.get(node.label) ?? [], node]);
     for (const node of typed)
       for (const field of node.fields ?? []) {
-        const candidates = (field.type ? types.get(field.type) ?? [] : []).filter((type) => this.#visible(type.owner, node.owner));
+        const candidates = (field.type ? types.get(field.type) ?? [] : []).filter((type) => this.#resolver.visible(type.owner, node.owner));
         field.ref = (candidates.find((type) => type.owner === node.owner) ?? candidates[0])?.id ?? null;
         if (field.ref)
           this.#addEdge(node.id, field.ref, "field", `${field.name}${field.array ? "[]" : ""}`, field.at);
@@ -1007,61 +1862,52 @@ ${label ?? ""}`;
     else
       this.#edges.set(key, { from, to, kind, label, count: 1, at });
   }
-  #guard(node, guard, file) {
-    const [role, local] = guard.includes(" ") ? guard.split(" ") : [null, guard];
-    if (!local || local === "?")
-      return;
-    this.#addEdge(node.id, this.#guardIdOf(local, file), "guard", role, node.at);
-  }
-  #declareGuards(facts) {
-    const factories = new Map;
-    for (const file of facts)
-      for (const fact of file.guardFactories) {
-        const factory = { fact, owner: file.owner, fileName: file.fileName, made: [] };
-        factories.set(fact.name, [...factories.get(fact.name) ?? [], factory]);
-      }
-    const sameFile = (factory, name) => name ? factories.get(name)?.find((other) => other.fileName === factory.fileName) : undefined;
-    const declare = (guard, factory) => {
-      this.#guards.set(guard.name, [...this.#guards.get(guard.name) ?? [], guard]);
-      factory?.made.push(guard);
-    };
-    const madeBy = (factory, fileName, extent) => {
-      const parts = [{ fileName, extent }];
-      const seen = new Set;
-      for (let current = factory;current && !seen.has(current); current = sameFile(current, current.fact.via)) {
-        seen.add(current);
-        parts.push({ fileName: current.fileName, extent: current.fact.extent });
-      }
-      return parts;
-    };
-    for (const file of facts) {
-      const { owner, fileName } = file;
-      for (const { name, span, extent, scope, doc, factory: callee } of file.guards) {
-        const factory = callee ? factories.get(callee)?.find((other) => other.fileName === fileName) : undefined;
-        declare({ name, owner, span, scope, doc, parts: madeBy(factory, fileName, extent) }, factory);
+  #addGuarded(file) {
+    const { owner } = file;
+    for (const slice of file.slices) {
+      const refName = slice.model;
+      if (!refName)
+        continue;
+      const fallback = this.#addNode(this.#key("slice", owner, refName), "slice", owner, refName, "", slice.span, slice.guards.map((guard) => guardLabelOf(guard, file.guardLabels)));
+      for (const guard of slice.guards)
+        this.#guard(fallback, guard, file);
+      for (const key of slice.keys) {
+        const detail = [
+          ...key.guards.map((guard) => guardLabelOf(guard, file.guardLabels)),
+          ...key.live ? ["live"] : []
+        ];
+        const node = this.#addMember("slice", owner, refName, key, `${refName}.${key.name}`, file.fileName, detail);
+        for (const guard of key.guards)
+          this.#guard(node, guard, file);
       }
-      for (const { name, span, extent, doc, callee } of file.guardCalls) {
-        const imported = file.imports.find((item) => item.name === callee);
-        if (!imported)
-          continue;
-        const from = this.#ownerOfSpecifier(fileName, imported.from);
-        const candidates = factories.get(imported.imported === "default" || imported.imported === "*" ? callee : imported.imported) ?? [];
-        const factory = candidates.find((other) => other.owner === from) ?? this.#soleVisible(candidates, from ?? owner);
-        if (factory)
-          declare({ name, owner, span, scope: factory.fact.scope, doc, parts: madeBy(factory, fileName, extent) }, factory);
+    }
+    for (const endpoint of file.endpoints) {
+      const refName = endpoint.model;
+      if (!refName)
+        continue;
+      for (const key of endpoint.keys) {
+        const detail = [
+          ...key.verb ? [key.verb] : [],
+          ...key.guards.map((guard) => guardLabelOf(guard, file.guardLabels))
+        ];
+        const node = this.#addMember("endpoint", owner, refName, key, `${refName}.${key.name}`, file.fileName, detail);
+        for (const guard of key.guards)
+          this.#guard(node, guard, file);
       }
     }
-    for (const list of factories.values())
-      for (const { fact, made } of list)
-        if (made.every((guard) => !guard.doc))
-          for (const guard of made)
-            guard.doc = fact.doc;
-    for (const list of this.#guards.values())
-      for (const guard of list)
-        this.#guardNodeOf(guard);
+  }
+  #guard(node, guard, file) {
+    const [, role = null, local = guard] = guard.match(/^([\w$]+) (.+)$/) ?? [];
+    if (!local || local === "?")
+      return;
+    const id = local.includes("@") ? this.#madeInPlaceIdOf(local, file) : this.#guardIdOf(local, file);
+    if (id)
+      this.#addEdge(node.id, id, "guard", role, node.at);
   }
   #guardIdOf(local, site) {
-    const found = this.#findGuard(local, site, 0);
+    const found = this.#resolver.find(local, site);
+    if ("external" in found)
+      return null;
     if ("guard" in found)
       return this.#guardNodeOf(found.guard);
     const { name, from } = found;
@@ -1074,99 +1920,18 @@ ${label ?? ""}`;
       node.doc = builtin.doc;
     return node.id;
   }
-  #findGuard(local, site, depth) {
-    const [head = local, member] = local.split(".");
-    const imported = site.imports.find((item) => item.name === head);
-    const from = imported ? this.#ownerOfSpecifier(site.fileName, imported.from) : undefined;
-    const holder = imported ? from : site.owner;
-    if (member && imported?.imported !== "*" && holder !== undefined && holder !== frameworkOwner && depth < maxMapDepth) {
-      const objectName = imported && imported.imported !== "default" ? imported.imported : head;
-      for (const entry of this.#mapEntriesOf(objectName, member, imported ? null : site.fileName, holder)) {
-        const found = this.#findGuard(entry.name, entry.site, depth + 1);
-        if ("guard" in found)
-          return found;
-      }
-    }
-    const name = member ?? (imported && imported.imported !== "default" && imported.imported !== "*" ? imported.imported : head);
-    const declared = this.#guards.get(name) ?? [];
-    const guard = from === undefined ? declared.find((other) => other.owner === site.owner) ?? declared.find((other) => this.#visible(other.owner, site.owner)) : declared.find((other) => other.owner === from) ?? (from === frameworkOwner ? undefined : this.#soleVisible(declared, from));
-    return guard ? { guard } : { name, from };
-  }
-  #mapEntriesOf(objectName, member, fileName, owner) {
-    const key = `${objectName}
-${member}
-${fileName ?? ""}
-${owner ?? ""}`;
-    const cached = this.#mapEntries.get(key);
-    if (cached)
-      return cached;
-    const { ts, reader } = this.#source;
-    const entries = [];
-    const fileNames = [
-      ...fileName ? [fileName] : [],
-      ...this.#source.files.filter(([other, words]) => other !== fileName && owner !== null && !testFilePattern.test(other) && words.includes(`
-${objectName}
-`) && words.includes(`
-${member}
-`) && this.#source.ownerOf(other) === owner).map(([other]) => other)
-    ];
-    for (const holder of fileNames) {
-      const text = this.#source.readText(holder);
-      if (text === undefined)
-        continue;
-      const source = this.#source.parse(holder, text);
-      const site = { fileName: holder, owner: this.#source.ownerOf(holder), imports: reader.importsIn(source) };
-      for (const statement of source.statements) {
-        if (!ts.isVariableStatement(statement))
-          continue;
-        const map = statement.declarationList.declarations.find((declaration) => ts.isIdentifier(declaration.name) && declaration.name.text === objectName)?.initializer;
-        const object = map && reader.unwrap(map);
-        if (!object || !ts.isObjectLiteralExpression(object))
-          continue;
-        for (const property of object.properties) {
-          if (ts.isShorthandPropertyAssignment(property) && property.name.text === member)
-            entries.push({ name: member, site });
-          if (!ts.isPropertyAssignment(property) || !(ts.isIdentifier(property.name) || ts.isStringLiteral(property.name)) || property.name.text !== member)
-            continue;
-          const value = reader.unwrap(property.initializer);
-          if (ts.isIdentifier(value))
-            entries.push({ name: value.text, site });
-          else if (ts.isPropertyAccessExpression(value) && ts.isIdentifier(value.expression))
-            entries.push({ name: `${value.expression.text}.${value.name.text}`, site });
-        }
-      }
-    }
-    this.#mapEntries.set(key, entries);
-    return entries;
-  }
-  #declarationOf(owner, name, near) {
-    const key = `${owner}
-${name}
-${near ?? ""}`;
-    const cached = this.#declarations.get(key);
-    if (cached !== undefined)
-      return cached;
-    const isNear = (fileName) => {
-      const relative = this.#source.relative(fileName);
-      return !!near && (relative.startsWith(`${near}/`) || relative.replace(/\.tsx?$/, "") === near);
-    };
-    const candidates = this.#source.files.filter(([fileName, words]) => !testFilePattern.test(fileName) && words.includes(`
-${name}
-`) && this.#source.ownerOf(fileName) === owner).map(([fileName]) => fileName);
-    let found = null;
-    for (const fileName of [...candidates.filter(isNear), ...candidates.filter((other) => !isNear(other))]) {
-      const text = this.#source.readText(fileName);
-      if (text === undefined)
-        continue;
-      const source = this.#source.parse(fileName, text);
-      const declared = this.#routes.declarationIn(source, name);
-      if (!declared)
-        continue;
-      found = { source, statement: declared.statement, declared: declared.declared };
-      break;
-    }
-    this.#declarations.set(key, found);
-    return found;
+  #madeInPlaceIdOf(name, file) {
+    const made = this.#resolver.madeInPlace(file.fileName, name);
+    if (made)
+      return this.#guardNodeOf(made);
+    const head = name.slice(name.indexOf(":") + 1, name.indexOf("@")).split(".")[0] ?? name;
+    const imported = file.imports.find((item) => item.name === head);
+    const from = imported ? this.#resolver.ownerOfSpecifier(file.fileName, imported.from) : file.owner;
+    if (from === undefined || from === frameworkOwner)
+      return null;
+    const scope = `${this.#resolver.inOwner(file.fileName, file.owner)}#${name}`;
+    const label = guardLabelOf(name, file.guardLabels);
+    return this.#addNode(this.#key("guard", file.owner, scope), "guard", file.owner, null, name, null, [], label).id;
   }
   #addRoutes() {
     const routes = [];
@@ -1219,22 +1984,23 @@ ${dir}`, node);
   }
   #routeGuardIdOf({ name: local, local: declared }, fact, text) {
     if (declared) {
-      const file = this.#source.relative(fact.fileName).slice(fact.owner.length + 1);
-      const id = this.#key("guard", fact.owner, `${file}#${local}`);
+      const id = this.#key("guard", fact.owner, `${this.#resolver.inOwner(fact.fileName, fact.owner)}#${local}`);
       return this.#routeGuardNodeOf(id, fact.owner, local, declared.span, declared.doc, text, declared.extent);
     }
-    const imported = fact.imports.find((item) => item.name === local);
-    if (!imported)
+    const [head = local, member] = local.split(".");
+    const imported = fact.imports.find((item) => item.name === head);
+    if (!imported || member && imported.imported !== "*")
       return null;
-    const name = imported.imported !== "default" && imported.imported !== "*" ? imported.imported : local;
-    const from = this.#ownerOfSpecifier(fact.fileName, imported.from);
+    const name = member ?? (imported.imported !== "default" && imported.imported !== "*" ? imported.imported : local);
+    const from = this.#resolver.ownerOfSpecifier(fact.fileName, imported.from);
     if (!from || from === frameworkOwner)
       return null;
-    const found = this.#declarationOf(from, name, this.#pathOfSpecifier(fact.fileName, imported.from));
+    const found = this.#resolver.declarationOf(from, name, this.#resolver.pathOfSpecifier(fact.fileName, imported.from));
     if (!found)
       return null;
     const { reader } = this.#source;
-    return this.#routeGuardNodeOf(this.#key("guard", from, name), from, name, reader.spanOf(found.source, found.declared), reader.docOf(found.source, found.statement), found.source.text, reader.extentOf(found.source, found.statement));
+    const owner = this.#source.ownerOf(found.source.fileName) ?? from;
+    return this.#routeGuardNodeOf(this.#key("guard", owner, `${this.#resolver.inOwner(found.source.fileName, owner)}#${found.name}`), owner, found.name, reader.spanOf(found.source, found.declared), reader.docOf(found.source, found.statement), found.source.text, found.extent);
   }
   #routeGuardNodeOf(id, owner, name, span, doc, text, extent) {
     const isNew = !this.#nodes.has(id);
@@ -1244,60 +2010,22 @@ ${dir}`, node);
     this.#digest(node, text, extent);
     return node.id;
   }
-  #adaptorIdOf(local, file) {
-    const [head, member] = local.split(".");
-    const imported = file.imports.find((item) => item.name === head);
-    const from = imported ? this.#ownerOfSpecifier(file.fileName, imported.from) : undefined;
-    const name = member ?? (imported && imported.imported !== "default" && imported.imported !== "*" ? imported.imported : head);
-    const declared = this.#adaptors.get(name) ?? [];
-    const found = from === undefined ? declared.find((adaptor) => adaptor.owner === file.owner) ?? declared.find((adaptor) => this.#visible(adaptor.owner, file.owner)) : declared.find((adaptor) => adaptor.owner === from) ?? (from === frameworkOwner ? undefined : declared.find((adaptor) => this.#visible(adaptor.owner, from)));
-    if (found)
-      return this.#adaptorNodeOf(found);
-    const owner = from === frameworkOwner ? null : imported ? from ?? null : file.owner;
-    const detail = from === frameworkOwner ? [frameworkOwner] : [];
-    return this.#addNode(this.#key("adaptor", owner, name), "adaptor", owner, null, name, null, detail).id;
-  }
-  #adaptorNodeOf({ fact, owner, fileName }) {
-    const id = this.#key("adaptor", owner, fact.name);
-    const detail = fact.refName ? [fact.refName] : [];
-    const node = this.#addNode(id, "adaptor", owner, null, fact.name, fact.span, detail);
-    if (fact.doc && !node.doc)
-      node.doc = fact.doc;
-    this.#digest(node, this.#source.readText(fileName), fact.extent);
-    return node.id;
-  }
-  #guardNodeOf({ name, owner, span, scope, doc, parts }) {
-    const node = this.#addNode(this.#key("guard", owner, name), "guard", owner, null, name, span, scope ? [scope] : []);
+  #guardNodeOf({ name, owner, span, scope, doc, parts, file, label }) {
+    const id = this.#key("guard", owner, file ? `${file}#${name}` : name);
+    const node = this.#addNode(id, "guard", owner, null, name, span, scope ? [scope] : [], label ?? name);
     if (doc && !node.doc)
       node.doc = doc;
-    const digest = node.digest ? null : this.#hashOf(...parts.map(({ fileName, extent }) => [
-      this.#source.readText(fileName),
-      extent
-    ]));
-    if (digest)
-      node.digest = digest;
+    if (node.digest)
+      return node.id;
+    const digest = this.#hashOf(...parts.map(({ fileName, extent }) => [this.#source.readText(fileName), extent]));
+    if (!digest)
+      return node.id;
+    node.digest = digest;
+    const sources = [...new Set(parts.map(({ fileName }) => this.#source.relative(fileName)))].filter((source) => source !== node.at?.file);
+    if (sources.length)
+      node.sources = sources;
     return node.id;
   }
-  #ownerOfSpecifier(fileName, specifier) {
-    if (frameworkPattern.test(specifier))
-      return frameworkOwner;
-    const path = this.#pathOfSpecifier(fileName, specifier);
-    return path === null ? undefined : ownerOf(path) ?? undefined;
-  }
-  #pathOfSpecifier(fileName, specifier) {
-    const alias = specifier.match(aliasPattern);
-    if (alias)
-      return `${alias[1]}/${alias[2]}${specifier.slice(alias[0].length)}`;
-    if (!specifier.startsWith("."))
-      return null;
-    const segments = this.#source.relative(fileName).split("/").slice(0, -1);
-    for (const segment of specifier.split("/"))
-      if (segment === "..")
-        segments.pop();
-      else if (segment !== ".")
-        segments.push(segment);
-    return segments.join("/");
-  }
   #moduleDirOf(fileName) {
     const dir = this.#source.relative(fileName).match(moduleDirPattern)?.[1] ?? null;
     return dir?.startsWith("_") && !dir.startsWith("__") ? dir.slice(1) : dir;
@@ -1333,20 +2061,13 @@ ${dir}`, node);
     visit(constant);
     return [...fields.values()];
   }
-  #visible(target, from) {
-    return !from || !target || target === from || target.startsWith("libs/");
-  }
-  #soleVisible(declared, from) {
-    const visible = declared.filter((other) => this.#visible(other.owner, from));
-    return visible.length === 1 ? visible[0] : undefined;
-  }
   #targetNodeOf({ family, owner, refName, sourceKey }) {
     const isDefault = /^[A-Z]/.test(sourceKey);
     const id = family === "slice" || family === "query" ? this.#key(family, owner, refName, isDefault ? "" : sourceKey) : family === "model" || family === "formSetter" ? this.#key("model", owner, refName) : family === "endpoint" ? this.#key("endpoint", owner, refName, sourceKey) : null;
     return id && this.#nodes.has(id) ? id : null;
   }
   #membersNamed(kind, name, owner, refName) {
-    const nodes = (this.#members.get(`${kind}:${name}`) ?? []).filter((node) => (!refName || node.module === refName) && this.#visible(node.owner, owner));
+    const nodes = (this.#members.get(`${kind}:${name}`) ?? []).filter((node) => (!refName || node.module === refName) && this.#resolver.visible(node.owner, owner));
     const own = nodes.filter((node) => node.owner === owner);
     return (own.length ? own : nodes).map((node) => node.id);
   }
@@ -1391,10 +2112,8 @@ st
     visit(source);
   }
   #link(fileName, source, identifier, chain, context, owner) {
-    const plugged = chain?.length === 2 && chain[0] === "this" && context.kind === "method" && this.#isServiceThis(identifier) ? this.#plugs.get(`${context.owner ?? ""}
-${context.module}
-${chain[1]}`) : undefined;
-    const resolved = plugged ? [plugged] : this.#source.resolve(fileName, identifier).map((target) => this.#targetNodeOf(target)).filter((id) => id !== null);
+    const plugged = chain?.length === 2 && chain[0] === "this" && context.kind === "method" && this.#isServiceThis(identifier) ? this.#adaptors.pluggedOf(context.owner, context.module, chain[1]) : [];
+    const resolved = plugged.length ? plugged : this.#source.resolve(fileName, identifier).map((target) => this.#targetNodeOf(target)).filter((id) => id !== null);
     const targets = resolved.length ? resolved : this.#plainTargetsOf(chain, identifier.text, context, owner);
     if (!targets.length)
       return;
@@ -1700,6 +2419,10 @@ var endpointNames = (key) => {
 };
 
 // pkgs/@akanjs/language/nameTable.ts
+var guardDetailOf = (facts, guards) => {
+  const labels = Object.assign({}, ...facts.map((file) => file.guardLabels));
+  return guards.length ? [`guards: ${guards.map((guard) => guardLabelOf(guard, labels)).join(", ")}`] : [];
+};
 var capitalize3 = (text) => text.charAt(0).toUpperCase() + text.slice(1);
 
 class NameTable {
@@ -1799,7 +2522,7 @@ class NameTable {
         role: "sig",
         gate: "sig",
         label: sliceClass.name,
-        detail: sliceClass.guards.length ? [`guards: ${sliceClass.guards.join(", ")}`] : []
+        detail: guardDetailOf(facts, sliceClass.guards)
       });
     if (modelDoc)
       this.#add({
@@ -1864,7 +2587,7 @@ class NameTable {
         sourceKey: slice.name,
         span: slice.span,
         label: `slice ${refName} (default)`,
-        detail: slice.guards.length ? [`guards: ${slice.guards.join(", ")}`] : []
+        detail: guardDetailOf(facts, slice.guards)
       };
       this.#addSliceNames(defaultTarget, refName, "", modelNameSet);
       for (const key of slice.keys)
@@ -1874,7 +2597,7 @@ class NameTable {
           sourceKey: key.name,
           span: key.span,
           label: `slice ${key.name}`,
-          detail: [...key.guards.length ? [`guards: ${key.guards.join(", ")}`] : [], ...key.live ? ["live"] : []]
+          detail: [...guardDetailOf(facts, key.guards), ...key.live ? ["live"] : []]
         }, refName, key.name, modelNameSet, slice.name);
     }
     if (filterClass) {
@@ -1931,7 +2654,7 @@ class NameTable {
           role: key.verb === "pubsub" ? "subscribe" : "listen",
           gate: null,
           label: `${key.verb} ${key.name}`,
-          detail: key.guards.length ? [`guards: ${key.guards.join(", ")}`] : []
+          detail: guardDetailOf(facts, key.guards)
         });
       }
   }
@@ -1988,15 +2711,13 @@ var sourcePattern = /\.(constant|document|service|signal|store)\.ts$/;
 var dictionaryPattern = /\.dictionary\.ts$/;
 var srvkitPattern = /\/srvkit\//;
 var wordPattern = /[A-Za-z_$][\w$]*/g;
-var identifierPattern = /^[A-Za-z_$][\w$]*$/;
-var regExpSpecials = /[\\^$.*+?()[\]{}|]/g;
+var identifierPattern2 = /^[A-Za-z_$][\w$]*$/;
 var stateReceivers = new Set(["use", "sel", "get", "do"]);
 var lensFamilies = new Set(["slice", "query", "formSetter", "storeState", "endpoint"]);
 var modellessFamilies = new Set(["query", "storeState", "endpoint"]);
 var gateWords = { srv: "srv", sig: "sig", db: "db", slice: "slice" };
 var parseCacheSize = 64;
 var pathOf = (fileName) => fileName.replace(/\\/g, "/");
-var escapeRegExp = (text) => text.replace(regExpSpecials, (special) => `\\${special}`);
 var receiverGap = String.raw`(?:\s|\)|\/\*[\s\S]*?\*\/)*`;
 
 class AkanIndex {
@@ -2099,7 +2820,7 @@ ${[...new Set(text.match(wordPattern))].join(`
   }
   renameAt(givenName, offset, newKey, readText) {
     const sources = this.#sourceEntriesAt(pathOf(givenName), offset).filter((entry) => entry.renamed);
-    if (!sources.length || !identifierPattern.test(newKey))
+    if (!sources.length || !identifierPattern2.test(newKey))
       return null;
     return [
       { span: sources[0].span, newText: newKey },
@@ -2127,6 +2848,8 @@ canPass
 adapt
 `) || words.includes(`
 dangerouslyAdapt
+`) || words.includes(`
+applyAdaptor
 `);
   }
   static #sourceKeyOf({ family, sourceKey, label, detail, span }) {
@@ -2807,6 +3530,11 @@ ${union.name}`)));
       const field = this.#memberOf(this.#classOf(receiver), receiver.name.text);
       return field && ts.isPropertyDeclaration(field) ? this.#namesIn(field.type) : new Set;
     }
+    if (ts.isCallExpression(receiver) && ts.isPropertyAccessExpression(receiver.expression) && receiver.expression.expression.kind === ts.SyntaxKind.ThisKeyword) {
+      const field = this.#memberOf(this.#classOf(receiver), receiver.expression.name.text);
+      const type = field && ts.isPropertyDeclaration(field) ? field.type : undefined;
+      return type && ts.isFunctionTypeNode(type) ? this.#namesIn(type.type) : new Set;
+    }
     return this.#declaredTypeNames(receiver) ?? new Set;
   }
   #memberName(name) {