@akanjs/language 3.1.2-rc.4 → 3.2.0-rc.0

package/index.js

@@ -71,6 +71,721 @@ class AkanGraphDiff {
     return node.fields ? { ...node, fields: node.fields.map(({ digest: _field, ...field }) => field) } : node;
   }
 }
+// pkgs/@akanjs/language/moduleFacts.ts
+var testFilePattern = /\.(?:test|spec)\.tsx?$/;
+var moduleCallees = new Set([
+  "via",
+  "from",
+  "into",
+  "serve",
+  "slice",
+  "endpoint",
+  "internal",
+  "store",
+  "enumOf",
+  "adapt",
+  "dangerouslyAdapt"
+]);
+var intervalUnits = [
+  [86400000, "d"],
+  [3600000, "h"],
+  [60000, "m"],
+  [1000, "s"]
+];
+var argMethods = new Set(["param", "body", "search", "room", "msg"]);
+var ownerOf = (relativePath) => {
+  const [root, name] = relativePath.split("/");
+  return (root === "apps" || root === "libs") && name ? `${root}/${name}` : null;
+};
+var createFactReader = (ts, ast) => {
+  const spanOf = (source, node) => {
+    const start = node.getStart(source);
+    const end = node.getEnd();
+    const head = source.getLineAndCharacterOfPosition(start);
+    const tail = source.getLineAndCharacterOfPosition(end);
+    return {
+      fileName: source.fileName,
+      start,
+      end,
+      line: head.line,
+      character: head.character,
+      endLine: tail.line,
+      endCharacter: tail.character
+    };
+  };
+  const extentOf = (source, node) => ({
+    start: node.getStart(source),
+    end: node.getEnd()
+  });
+  const unwrap = (expression) => {
+    let current = expression;
+    while (ts.isParenthesizedExpression(current) || ts.isAsExpression(current) || ts.isSatisfiesExpression(current))
+      current = current.expression;
+    return current;
+  };
+  const moduleRefOf = (expression, holder) => {
+    let current = expression && unwrap(expression);
+    while (current && ts.isCallExpression(current) && ts.isPropertyAccessExpression(current.expression))
+      current = current.expression.expression;
+    if (current && ts.isStringLiteral(current))
+      return current.text;
+    if (!current || !ts.isPropertyAccessExpression(current))
+      return null;
+    return ts.isIdentifier(current.expression) && current.expression.text === holder ? current.name.text : null;
+  };
+  const returnedObject = (builder) => builder ? ast.firstObjectReturnedByArrow(builder) : null;
+  const builderOf = (call) => [...call.arguments].reverse().find((arg) => ts.isArrowFunction(arg) || ts.isFunctionExpression(arg));
+  const guardNameOf = (expression) => {
+    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);
+    const methods = [];
+    while (ts.isCallExpression(root) && ts.isPropertyAccessExpression(root.expression) && ts.isCallExpression(unwrap(root.expression.expression))) {
+      methods.push(root.expression.name.text);
+      root = unwrap(root.expression.expression);
+    }
+    return { root: ts.isCallExpression(root) ? root : null, methods };
+  };
+  const keyName = (property) => ts.isPropertyAssignment(property) || ts.isMethodDeclaration(property) || ts.isShorthandPropertyAssignment(property) ? property.name : null;
+  const objectKeys = (source, object) => (object?.properties ?? []).flatMap((property) => {
+    const name = ast.propertyName(property);
+    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) => {
+    if (!ts.isPropertyAssignment(property))
+      return [];
+    const name = ast.nodeName(property.name);
+    if (!name)
+      return [];
+    const { root, methods } = chainOf(property.initializer);
+    return [
+      {
+        name,
+        span: spanOf(source, property.name),
+        extent: extentOf(source, property),
+        guards: root ? guardsIn(optionObjectOf(root)) : [],
+        live: methods.includes("live"),
+        argCount: methods.filter((method) => argMethods.has(method)).length
+      }
+    ];
+  });
+  const verbReaderOf = (parameter) => {
+    const verbs = new Map;
+    if (parameter && ts.isObjectBindingPattern(parameter.name))
+      for (const element of parameter.name.elements) {
+        const verb = element.propertyName ?? element.name;
+        if (ts.isIdentifier(verb) && ts.isIdentifier(element.name))
+          verbs.set(element.name.text, verb.text);
+      }
+    const holder = parameter && ts.isIdentifier(parameter.name) ? parameter.name.text : null;
+    return (callee) => {
+      if (callee && ts.isIdentifier(callee))
+        return verbs.get(callee.text) ?? null;
+      if (callee && ts.isPropertyAccessExpression(callee) && ts.isIdentifier(callee.expression) && callee.expression.text === holder)
+        return callee.name.text;
+      return null;
+    };
+  };
+  const numberOf = (expression) => {
+    const value = unwrap(expression);
+    if (ts.isNumericLiteral(value))
+      return Number(value.text.replace(/_/g, ""));
+    if (!ts.isBinaryExpression(value))
+      return null;
+    const [left, right] = [numberOf(value.left), numberOf(value.right)];
+    if (left === null || right === null)
+      return null;
+    const operator = value.operatorToken.kind;
+    if (operator === ts.SyntaxKind.AsteriskToken)
+      return left * right;
+    if (operator === ts.SyntaxKind.PlusToken)
+      return left + right;
+    if (operator === ts.SyntaxKind.MinusToken)
+      return left - right;
+    return operator === ts.SyntaxKind.SlashToken && right ? left / right : null;
+  };
+  const durationOf = (expression, source) => {
+    if (!expression)
+      return null;
+    const ms = numberOf(expression);
+    if (ms === null)
+      return expression.getText(source);
+    const [size, unit] = intervalUnits.find(([size]) => ms >= size && ms % size === 0) ?? [1, "ms"];
+    return `${ms / size}${unit}`;
+  };
+  const modesOf = (option) => {
+    const object = option && unwrap(option);
+    if (!object || !ts.isObjectLiteralExpression(object))
+      return [];
+    return object.properties.filter(ts.isPropertyAssignment).flatMap((property) => {
+      const name = ast.nodeName(property.name);
+      const value = unwrap(property.initializer);
+      if (name === "enabled")
+        return value.kind === ts.SyntaxKind.FalseKeyword ? ["disabled"] : [];
+      if (name === "once")
+        return value.kind === ts.SyntaxKind.TrueKeyword ? ["once"] : [];
+      if (name === "lock")
+        return value.kind === ts.SyntaxKind.FalseKeyword ? ["unlocked"] : [];
+      if (name !== "serverMode" && name !== "operationMode")
+        return [];
+      const values = ts.isArrayLiteralExpression(value) ? [...value.elements] : [value];
+      return values.flatMap((element) => ts.isStringLiteralLike(element) ? [element.text] : ts.isPropertyAccessExpression(element) ? [element.name.text] : []);
+    });
+  };
+  const internalKeysOf = (source, builder) => {
+    const verbOf = verbReaderOf(builder?.parameters[0]);
+    return (returnedObject(builder)?.properties ?? []).flatMap((property) => {
+      if (!ts.isPropertyAssignment(property))
+        return [];
+      const name = ast.nodeName(property.name);
+      if (!name)
+        return [];
+      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 option = type === "initialize" || type === "destroy" ? first : second;
+      return [
+        {
+          name,
+          span: spanOf(source, property.name),
+          extent: extentOf(source, property),
+          type,
+          schedule,
+          modes: modesOf(option)
+        }
+      ];
+    });
+  };
+  const plugsOf = (source, builder) => {
+    const verbOf = verbReaderOf(builder?.parameters[0]);
+    return (returnedObject(builder)?.properties ?? []).flatMap((property) => {
+      if (!ts.isPropertyAssignment(property))
+        return [];
+      const name = ast.nodeName(property.name);
+      const { root } = chainOf(property.initializer);
+      const [target] = root && verbOf(root.expression) === "plug" ? root.arguments : [];
+      const targetName = target && guardNameOf(target);
+      return name && targetName ? [{ name, span: spanOf(source, property.name), target: targetName }] : [];
+    });
+  };
+  const endpointKeysOf = (source, builder) => {
+    const verbOf = verbReaderOf(builder?.parameters[0]);
+    return (returnedObject(builder)?.properties ?? []).flatMap((property) => {
+      if (!ts.isPropertyAssignment(property))
+        return [];
+      const name = ast.nodeName(property.name);
+      if (!name)
+        return [];
+      const { root, methods } = chainOf(property.initializer);
+      return [
+        {
+          name,
+          span: spanOf(source, property.name),
+          extent: extentOf(source, property),
+          verb: root ? verbOf(root.expression) : null,
+          guards: root ? guardsIn(optionObjectOf(root)) : [],
+          argCount: methods.filter((method) => argMethods.has(method)).length
+        }
+      ];
+    });
+  };
+  const filterQueriesOf = (source, builder) => {
+    const query = returnedObject(builder)?.properties.find((property) => ts.isPropertyAssignment(property) && ast.nodeName(property.name) === "query")?.initializer;
+    return query && ts.isObjectLiteralExpression(query) ? objectKeys(source, query) : [];
+  };
+  const typeOf = (expression) => {
+    const value = expression && unwrap(expression);
+    if (value && ts.isArrayLiteralExpression(value))
+      return { type: typeOf(value.elements[0]).type, array: true };
+    return { type: value ? ast.expressionName(value) : null, array: false };
+  };
+  const fieldsOf = (source, object) => (object?.properties ?? []).flatMap((property) => {
+    const name = ast.propertyName(property);
+    const node = keyName(property);
+    if (!name || !node)
+      return [];
+    const { root, methods } = ts.isPropertyAssignment(property) ? chainOf(property.initializer) : { root: null, methods: [] };
+    return [
+      {
+        name,
+        span: spanOf(source, node),
+        extent: extentOf(source, property),
+        ...typeOf(root?.arguments[0]),
+        optional: methods.includes("optional")
+      }
+    ];
+  });
+  const constantOf = (source, name, call) => {
+    const parents = call.arguments.map(unwrap).filter((arg) => ts.isIdentifier(arg) || ts.isPropertyAccessExpression(arg)).map((arg) => ast.expressionName(arg)).filter((parent) => parent !== null);
+    const fields = call.arguments.flatMap((arg) => fieldsOf(source, ast.firstObjectReturnedByArrow(arg)));
+    return { ...name, parents, fields };
+  };
+  const enumValuesOf = (call) => {
+    const list = call.arguments[1] && unwrap(call.arguments[1]);
+    if (!list || !ts.isArrayLiteralExpression(list))
+      return [];
+    return list.elements.flatMap((element) => ts.isStringLiteralLike(element) ? [element.text] : []);
+  };
+  const methodsOf = (source, statement) => statement.members.flatMap((member) => {
+    if (!ts.isMethodDeclaration(member) || !member.body)
+      return [];
+    const name = ast.nodeName(member.name);
+    if (!name || ts.getModifiers(member)?.some(({ kind }) => kind === ts.SyntaxKind.StaticKeyword))
+      return [];
+    return [{ name, span: spanOf(source, member.name), extent: extentOf(source, member) }];
+  });
+  const importsOf = (statement) => {
+    const { importClause, moduleSpecifier } = statement;
+    if (!importClause || !ts.isStringLiteral(moduleSpecifier))
+      return [];
+    const from = moduleSpecifier.text;
+    const bindings = importClause.namedBindings;
+    return [
+      ...importClause.name ? [{ name: importClause.name.text, imported: "default", from }] : [],
+      ...bindings && ts.isNamespaceImport(bindings) ? [{ name: bindings.name.text, imported: "*", from }] : [],
+      ...bindings && ts.isNamedImports(bindings) ? bindings.elements.map((element) => ({
+        name: element.name.text,
+        imported: (element.propertyName ?? element.name).text,
+        from
+      })) : []
+    ];
+  };
+  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()) ?? [];
+    const comments = [];
+    let end = node.getStart(source);
+    for (const range of [...ranges].reverse()) {
+      if ((text.slice(range.end, end).match(/\n/g)?.length ?? 0) > 1)
+        break;
+      comments.unshift(text.slice(range.pos, range.end));
+      end = range.pos;
+    }
+    const lines = comments.flatMap((comment) => comment.split(`
+`)).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 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 facts = {
+      fileName: source.fileName,
+      owner,
+      imports,
+      ...guardsOf(source, imports),
+      constants: [],
+      enums: [],
+      filters: [],
+      models: [],
+      services: [],
+      slices: [],
+      endpoints: [],
+      internals: [],
+      adaptors: [],
+      stores: []
+    };
+    for (const statement of source.statements) {
+      if (!ts.isClassDeclaration(statement) || !statement.name)
+        continue;
+      const heritage = ast.heritageCallNamed(statement, moduleCallees);
+      if (!heritage)
+        continue;
+      const { callee, call } = heritage;
+      const name = { name: statement.name.text, span: spanOf(source, statement.name) };
+      const builder = builderOf(call);
+      if (callee === "via")
+        facts.constants.push(constantOf(source, name, call));
+      else if (callee === "enumOf")
+        facts.enums.push({ ...name, values: enumValuesOf(call) });
+      else if (callee === "from")
+        facts.filters.push({ ...name, queries: filterQueriesOf(source, builder) });
+      else if (callee === "into")
+        facts.models.push({ ...name, model: name.name.endsWith("Model") ? lowerFirst(name.name.slice(0, -5)) : null });
+      else if (callee === "serve")
+        facts.services.push({
+          ...name,
+          model: moduleRefOf(call.arguments[0], "db"),
+          methods: methodsOf(source, statement),
+          plugs: plugsOf(source, builder)
+        });
+      else if (callee === "slice")
+        facts.slices.push({
+          ...name,
+          model: moduleRefOf(call.arguments[0], "srv"),
+          guards: guardsIn(call.arguments.find(ts.isObjectLiteralExpression)),
+          keys: sliceKeysOf(source, builder)
+        });
+      else if (callee === "internal")
+        facts.internals.push({
+          ...name,
+          model: moduleRefOf(call.arguments[0], "srv"),
+          keys: internalKeysOf(source, builder)
+        });
+      else if (callee === "adapt" || callee === "dangerouslyAdapt") {
+        const refName = call.arguments[0] && unwrap(call.arguments[0]);
+        facts.adaptors.push({
+          ...name,
+          extent: extentOf(source, statement),
+          refName: refName && ts.isStringLiteralLike(refName) ? refName.text : null,
+          plugs: plugsOf(source, builder),
+          doc: docOf(source, statement)
+        });
+      } else if (callee === "endpoint")
+        facts.endpoints.push({
+          ...name,
+          model: moduleRefOf(call.arguments[0], "srv"),
+          keys: endpointKeysOf(source, builder)
+        });
+      else if (callee === "store")
+        facts.stores.push({
+          ...name,
+          model: moduleRefOf(call.arguments[0], "sig"),
+          stateKeys: objectKeys(source, returnedObject(builder)),
+          actions: methodsOf(source, statement)
+        });
+    }
+    return facts;
+  };
+  return { read, spanOf, extentOf, docOf, importsIn, moduleRefOf, chainOf, unwrap };
+};
+
+// pkgs/akanjs/common/trimSlashes.ts
+var trimTrailingSlashes = (value) => {
+  let end = value.length;
+  while (end > 0 && value[end - 1] === "/")
+    end -= 1;
+  return value.slice(0, end);
+};
+
+// pkgs/akanjs/common/routeConvention.ts
+var ROUTE_SOURCE_RE = /^\.\/(.+)\.(tsx|ts|jsx|js)$/;
+var RESERVED_ROUTE_FILES = new Set(["_layout", "_index", "_overrides"]);
+var INTERNAL_ROOT_LAYOUT_LEAF = "__root_layout";
+var IMPLICIT_LOCALE_SEGMENT = "[lang]";
+var DIRECTORY_SCOPED_LEAVES = new Set(["_layout", "_index", "_overrides"]);
+var PAGE_ROUTE_EXPORTS = new Set([
+  "default",
+  "pageConfig",
+  "head",
+  "generateHead",
+  "Loading",
+  "guard"
+]);
+var LAYOUT_ROUTE_EXPORTS = new Set([...PAGE_ROUTE_EXPORTS, "NotFound", "Error"]);
+var ROOT_LAYOUT_ROUTE_EXPORTS = new Set([
+  ...LAYOUT_ROUTE_EXPORTS,
+  "fonts",
+  "manifest",
+  "theme",
+  "reconnect",
+  "wsConnect",
+  "layoutStyle",
+  "viewport",
+  "McpAppRoot"
+]);
+var RESERVED_ROUTE_CONFIG_EXPORTS = new Set([...ROOT_LAYOUT_ROUTE_EXPORTS].filter((name) => name !== "default" && !/^[A-Z]/.test(name)));
+function parseRouteModuleKey(key) {
+  const match = ROUTE_SOURCE_RE.exec(key);
+  if (!match)
+    throw new Error(`[route-convention] invalid route module key: ${key}`);
+  const file = match[1];
+  const ext = match[2];
+  const moduleSegments = file.split("/").filter(Boolean);
+  const leaf = moduleSegments.at(-1);
+  if (!leaf)
+    throw new Error(`[route-convention] invalid route module key: ${key}`);
+  if (moduleSegments.includes(IMPLICIT_LOCALE_SEGMENT)) {
+    throw new Error(`[route-convention] Akan.js injects \`[lang]\` automatically. Move files one level up: ${key}`);
+  }
+  const isInternalRootLayout = leaf === INTERNAL_ROOT_LAYOUT_LEAF;
+  const kind = leaf === "_layout" || isInternalRootLayout ? "layout" : leaf === "_overrides" ? "overrides" : "page";
+  if (leaf.startsWith("_") && !RESERVED_ROUTE_FILES.has(leaf) && !isInternalRootLayout) {
+    throw new Error(`[route-convention] unsupported reserved route file "${leaf}" in ${key}`);
+  }
+  const sourceRouteSegments = DIRECTORY_SCOPED_LEAVES.has(leaf) || isInternalRootLayout ? moduleSegments.slice(0, -1) : moduleSegments;
+  const routeSegments = [IMPLICIT_LOCALE_SEGMENT, ...sourceRouteSegments];
+  for (const segment of routeSegments)
+    validateRouteSegment(segment, key);
+  return {
+    key,
+    kind,
+    routeSegments,
+    moduleSegments,
+    sourceRouteSegments,
+    ext,
+    leaf,
+    pattern: normalizeRoutePattern(routeSegments),
+    isInternalRootLayout
+  };
+}
+function tryParseRouteModuleKey(key) {
+  try {
+    return parseRouteModuleKey(key);
+  } catch {
+    return null;
+  }
+}
+function normalizeRoutePattern(segments) {
+  const parts = segments.map(routeSegmentToPatternPart).filter((part) => part.length > 0);
+  return trimTrailingSlashes(`/${parts.join("/")}`) || "/";
+}
+function routeSegmentToPatternPart(segment) {
+  if (/^\(.+\)$/.test(segment))
+    return "";
+  return segment.replace(/^\[([^\]]+)\]$/, ":$1");
+}
+function validateRouteSegment(segment, key) {
+  if (segment.includes("[...") || segment.includes("[[...")) {
+    throw new Error(`[route-convention] catch-all routes are not supported yet: ${key}`);
+  }
+  const dynamic = /^\[(.+)\]$/.exec(segment);
+  if (dynamic && (dynamic[1]?.includes("[") || dynamic[1]?.includes("]") || dynamic[1]?.startsWith("..."))) {
+    throw new Error(`[route-convention] invalid dynamic route segment "${segment}" in ${key}`);
+  }
+}
+
+// pkgs/@akanjs/language/routeFacts.ts
+class RouteFactReader {
+  static #pagePattern = /^((?:apps|libs)\/[^/]+)\/page\/((?!(?:.*\/)?\(libs\)\/).+\.tsx?)$/;
+  static #guardPattern = /\.guard\s*\(/;
+  static #aliasPattern = /^export default ([A-Za-z_$][\w$]*)\s*;?\s*$/m;
+  static #workspacePattern = /^(?:\.|@(?:apps|libs)\/)/;
+  #ts;
+  #reader;
+  #parse;
+  constructor(ts, reader, parse) {
+    this.#ts = ts;
+    this.#reader = reader;
+    this.#parse = parse;
+  }
+  static fileOf(relative) {
+    const match = relative.match(RouteFactReader.#pagePattern);
+    return match ? { owner: match[1], key: `./${match[2]}` } : null;
+  }
+  read(fileName, info, text, words) {
+    const ts = this.#ts;
+    const parsed = tryParseRouteModuleKey(info.key);
+    if (!parsed || parsed.kind === "overrides" || parsed.isInternalRootLayout)
+      return null;
+    const starts = [...text.matchAll(/^export default\b/gm)].map(({ index }) => index);
+    const source = RouteFactReader.#guardPattern.test(text) || starts.length > 1 ? this.#parse(fileName, text) : null;
+    const exported = source ? this.#exportOf(source) : null;
+    const start = exported ? exported.getStart(source ?? undefined) : starts[0] ?? 0;
+    const head = text.slice(0, start);
+    return {
+      fileName,
+      owner: info.owner,
+      kind: parsed.kind,
+      pattern: normalizeRoutePattern(parsed.sourceRouteSegments),
+      dir: parsed.moduleSegments.slice(0, -1),
+      isRoot: words.includes(`
+rootLayout
+`),
+      line: head.split(`
+`).length - 1,
+      character: start - head.lastIndexOf(`
+`) - 1,
+      guard: source && exported ? this.#guardOf(source, exported) : null,
+      imports: source ? this.#reader.importsIn(source) : [],
+      alias: source ? exported && ts.isExportAssignment(exported) && ts.isIdentifier(exported.expression) ? exported.expression.text : null : text.match(RouteFactReader.#aliasPattern)?.[1] ?? null
+    };
+  }
+  #exportOf(source) {
+    const ts = this.#ts;
+    return source.statements.find((statement) => ts.isExportAssignment(statement) || ts.canHaveModifiers(statement) && !!ts.getModifiers(statement)?.some(({ kind }) => kind === ts.SyntaxKind.DefaultKeyword)) ?? null;
+  }
+  declarationIn(source, name) {
+    const ts = this.#ts;
+    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 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;
+      if (name.text === "guard" && stage)
+        return { calls: this.#callsIn(source, stage), span: this.#reader.spanOf(source, name) };
+      current = this.#reader.unwrap(expression);
+    }
+    return null;
+  }
+  #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 calls = new Map;
+    const callOf = (name) => {
+      if (calls.has(name))
+        return true;
+      const declared = this.declarationIn(source, name);
+      if (!declared && !imported.has(name))
+        return false;
+      calls.set(name, {
+        name,
+        local: declared && {
+          span: this.#reader.spanOf(source, declared.declared),
+          extent: this.#reader.extentOf(source, declared.statement),
+          doc: this.#reader.docOf(source, declared.statement)
+        }
+      });
+      return true;
+    };
+    const visit = (node) => {
+      if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && callOf(node.expression.text))
+        return;
+      ts.forEachChild(node, visit);
+    };
+    if (ts.isIdentifier(stage))
+      callOf(stage.text);
+    else
+      visit(stage);
+    return [...calls.values()];
+  }
+}
+
 // pkgs/@akanjs/language/akanGraph.ts
 var capitalize = (text) => text.charAt(0).toUpperCase() + text.slice(1);
 var lowerFirst = (text) => text.charAt(0).toLowerCase() + text.slice(1);
@@ -80,6 +795,14 @@ var scalarPattern = /\/lib\/__scalar\/([^/]+)\/[^/]+\.constant\.ts$/;
 var moduleDirPattern = /\/lib\/([^/]+)\//;
 var typeKinds = new Set(["model", "scalar", "enum"]);
 var clientRoots = new Set(["fetch", "st", "sig"]);
+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;
@@ -87,8 +810,16 @@ 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;
   constructor(source) {
     this.#source = source;
+    this.#routes = new RouteFactReader(source.ts, source.reader, source.parse);
   }
   build() {
     const { facts } = this.#source;
@@ -100,6 +831,17 @@ 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);
     for (const file of facts) {
       const { owner } = file;
       const scalar = this.#source.relative(file.fileName).match(scalarPattern)?.[1];
@@ -130,6 +872,10 @@ 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));
       }
       for (const filter of file.filters) {
         if (!filter.name.endsWith("Filter"))
@@ -145,12 +891,12 @@ class GraphBuilder {
           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);
+          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);
+            this.#guard(node, guard, file);
         }
       }
       for (const endpoint of file.endpoints) {
@@ -161,9 +907,13 @@ class GraphBuilder {
           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);
+            this.#guard(node, guard, file);
         }
       }
+      for (const internal of file.internals)
+        for (const key of internal.keys)
+          if (internal.model && key.type !== "resolveField")
+            this.#addMember("internal", owner, internal.model, key, `${internal.name}.${key.name}`, file.fileName, [key.type, key.schedule, ...key.modes].filter((item) => item !== null));
       for (const store of file.stores)
         if (store.model)
           for (const action of store.actions)
@@ -180,6 +930,7 @@ class GraphBuilder {
         if (field.ref)
           this.#addEdge(node.id, field.ref, "field", `${field.name}${field.array ? "[]" : ""}`, field.at);
       }
+    this.#addRoutes();
     for (const [fileName, words] of this.#source.files)
       this.#walk(fileName, words);
     return {
@@ -223,43 +974,329 @@ class GraphBuilder {
     this.#members.set(byName, [...this.#members.get(byName) ?? [], node]);
     return node;
   }
-  #hashOf(text, { start, end }) {
-    if (!this.#source.digests || text === undefined)
+  #hashOf(...parts) {
+    if (!this.#source.digests)
+      return null;
+    let hash = 2166136261;
+    for (const [text, { start, end }] of parts) {
+      if (text === undefined)
+        return null;
+      for (let idx = start;idx < end; idx++) {
+        const code = text.charCodeAt(idx);
+        if (code !== 13)
+          hash = Math.imul(hash ^ code, 16777619);
+      }
+    }
+    return (hash >>> 0).toString(16).padStart(8, "0");
+  }
+  #digest(node, text, extent) {
+    const digest = node.digest ? null : this.#hashOf([text, extent]);
+    if (digest)
+      node.digest = digest;
+  }
+  #addEdge(from, to, kind, label, at) {
+    if (from === to)
+      return;
+    const key = `${from}
+${to}
+${kind}
+${label ?? ""}`;
+    const existing = this.#edges.get(key);
+    if (existing)
+      existing.count += 1;
+    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);
+      }
+      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 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);
+  }
+  #guardIdOf(local, site) {
+    const found = this.#findGuard(local, site, 0);
+    if ("guard" in found)
+      return this.#guardNodeOf(found.guard);
+    const { name, from } = found;
+    const isFramework = from === frameworkOwner || from === undefined && !!builtinGuards[name];
+    const builtin = isFramework ? builtinGuards[name] : undefined;
+    const owner = isFramework ? null : from ?? null;
+    const detail = [...builtin ? [builtin.scope] : [], ...isFramework ? [frameworkOwner] : []];
+    const node = this.#addNode(this.#key("guard", owner, name), "guard", owner, null, name, null, detail);
+    if (builtin)
+      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;
+  }
+  #addRoutes() {
+    const routes = [];
+    const layouts = new Map;
+    for (const [fileName, words] of this.#source.files) {
+      const relative = this.#source.relative(fileName);
+      const info = RouteFactReader.fileOf(relative);
+      const text = info ? this.#source.readText(fileName) : undefined;
+      const fact = info && text !== undefined ? this.#routes.read(fileName, info, text, words) : null;
+      if (!fact || text === undefined)
+        continue;
+      const span = {
+        fileName,
+        start: 0,
+        end: 0,
+        line: fact.line,
+        character: fact.character,
+        endLine: 0,
+        endCharacter: 0
+      };
+      const dir = `/${fact.dir.join("/")}`;
+      const guard = fact.guard ? ["guard"] : [];
+      const node = fact.kind === "layout" ? this.#addNode(this.#key("layout", fact.owner, dir), "layout", fact.owner, null, dir, span, [...fact.isRoot ? ["root"] : [], ...guard], `${dir === "/" ? "" : dir}/_layout`) : this.#addNode(this.#key("route", fact.owner, fact.pattern), "route", fact.owner, null, fact.pattern, span, guard);
+      this.#digest(node, text, { start: 0, end: text.length });
+      this.#routeFiles.set(relative, { id: node.id, alias: fact.alias });
+      if (fact.kind === "layout")
+        layouts.set(`${fact.owner}
+${dir}`, node);
+      routes.push({ fact, node });
+      for (const call of fact.guard?.calls ?? []) {
+        const id = this.#routeGuardIdOf(call, fact, text);
+        if (id && fact.guard)
+          this.#addEdge(node.id, id, "guard", null, this.#location(fact.guard.span));
+      }
+    }
+    const parentOf = ({ owner, dir, kind }) => {
+      for (let depth = kind === "layout" ? dir.length - 1 : dir.length;depth >= 0; depth--) {
+        const layout = layouts.get(`${owner}
+/${dir.slice(0, depth).join("/")}`);
+        if (layout)
+          return layout;
+      }
       return null;
-    let hash = 2166136261;
-    for (let idx = start;idx < end; idx++) {
-      const code = text.charCodeAt(idx);
-      if (code !== 13)
-        hash = Math.imul(hash ^ code, 16777619);
+    };
+    for (const { fact, node } of routes) {
+      const parent = parentOf(fact);
+      if (parent)
+        this.#addEdge(parent.id, node.id, "wraps", null, node.at);
     }
-    return (hash >>> 0).toString(16).padStart(8, "0");
   }
-  #digest(node, text, extent) {
-    const digest = node.digest ? null : this.#hashOf(text, extent);
+  #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}`);
+      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)
+      return null;
+    const name = imported.imported !== "default" && imported.imported !== "*" ? imported.imported : local;
+    const from = this.#ownerOfSpecifier(fact.fileName, imported.from);
+    if (!from || from === frameworkOwner)
+      return null;
+    const found = this.#declarationOf(from, name, this.#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));
+  }
+  #routeGuardNodeOf(id, owner, name, span, doc, text, extent) {
+    const isNew = !this.#nodes.has(id);
+    const node = this.#addNode(id, "guard", owner, null, name, span, ["route"]);
+    if (isNew && doc)
+      node.doc = doc;
+    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] : []);
+    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;
-  }
-  #addEdge(from, to, kind, label, at) {
-    if (from === to)
-      return;
-    const key = `${from}
-${to}
-${kind}
-${label ?? ""}`;
-    const existing = this.#edges.get(key);
-    if (existing)
-      existing.count += 1;
-    else
-      this.#edges.set(key, { from, to, kind, label, count: 1, at });
-  }
-  #guard(node, guard) {
-    const [role, name] = guard.includes(" ") ? guard.split(" ") : [null, guard];
-    if (!name || name === "?")
-      return;
-    const id = `guard:${name}`;
-    if (!this.#nodes.has(id))
-      this.#nodes.set(id, { id, kind: "guard", name, label: name, owner: null, module: null, detail: [], at: null });
-    this.#addEdge(node.id, id, "guard", role, node.at);
+    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;
@@ -280,7 +1317,7 @@ ${label ?? ""}`;
       for (const field of current.fields) {
         if (fields.has(field.name))
           continue;
-        const digest = this.#hashOf(this.#source.readText(field.span.fileName), field.extent);
+        const digest = this.#hashOf([this.#source.readText(field.span.fileName), field.extent]);
         fields.set(field.name, {
           name: field.name,
           type: field.type,
@@ -299,6 +1336,10 @@ ${label ?? ""}`;
   #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;
@@ -350,7 +1391,10 @@ st
     visit(source);
   }
   #link(fileName, source, identifier, chain, context, owner) {
-    const resolved = 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.#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 targets = resolved.length ? resolved : this.#plainTargetsOf(chain, identifier.text, context, owner);
     if (!targets.length)
       return;
@@ -365,6 +1409,16 @@ st
     for (const target of new Set(own.length ? own : targets))
       this.#addEdge(context.id, target, kind, identifier.text, at);
   }
+  #isServiceThis(identifier) {
+    const { ts } = this.#source;
+    for (let current = identifier.parent;!ts.isSourceFile(current); current = current.parent) {
+      if (ts.isMethodDeclaration(current) || ts.isAccessor(current) || ts.isConstructorDeclaration(current))
+        return ts.isClassDeclaration(current.parent) && ts.isSourceFile(current.parent.parent);
+      if (ts.isFunctionExpression(current) || ts.isFunctionDeclaration(current) || ts.isClassLike(current))
+        return false;
+    }
+    return false;
+  }
   #chainOf(expression) {
     const { ts } = this.#source;
     if (ts.isNonNullExpression(expression) || ts.isParenthesizedExpression(expression))
@@ -388,14 +1442,13 @@ st
     const name = declared && ts.isIdentifier(declared) && !isDefaultExport ? declared.text : "default";
     const relative = this.#source.relative(source.fileName);
     const owner = this.#source.ownerOf(source.fileName);
+    const extent = { start: top.getStart(source), end: top.getEnd() };
+    const routeFile = this.#routeFiles.get(relative);
+    const routeId = routeFile && (name === "default" || name === routeFile.alias) ? routeFile.id : undefined;
+    if (routeId)
+      return { id: routeId, kind: "component", owner, module: null, extent };
     const id = `component:${relative}#${name}`;
-    const context = {
-      id,
-      kind: "component",
-      owner,
-      module: null,
-      extent: { start: top.getStart(source), end: top.getEnd() }
-    };
+    const context = { id, kind: "component", owner, module: null, extent };
     if (this.#nodes.has(id))
       return context;
     const pagePrefix = owner ? `${owner}/page/` : null;
@@ -456,266 +1509,30 @@ var createAst = (ts) => {
       }
     }
     return null;
-  };
-  const heritageCallNamed = (node, names) => {
-    const heritage = node.heritageClauses?.flatMap((clause) => [...clause.types]) ?? [];
-    for (const { expression } of heritage) {
-      if (!ts.isCallExpression(expression))
-        continue;
-      const callee = expressionName(expression.expression);
-      if (callee && names.has(callee))
-        return { callee, call: expression };
-    }
-    return null;
-  };
-  const viaNames = new Set(["via"]);
-  const heritageCall = (node) => heritageCallNamed(node, viaNames)?.call ?? null;
-  return {
-    sourceFileFor,
-    nodeName,
-    propertyName,
-    expressionName,
-    callExpressionName,
-    firstObjectReturnedByArrow,
-    heritageCallNamed,
-    heritageCall
-  };
-};
-
-// pkgs/@akanjs/language/moduleFacts.ts
-var moduleCallees = new Set(["via", "from", "into", "serve", "slice", "endpoint", "store", "enumOf"]);
-var argMethods = new Set(["param", "body", "search", "room", "msg"]);
-var ownerOf = (relativePath) => {
-  const [root, name] = relativePath.split("/");
-  return (root === "apps" || root === "libs") && name ? `${root}/${name}` : null;
-};
-var createFactReader = (ts, ast) => {
-  const spanOf = (source, node) => {
-    const start = node.getStart(source);
-    const end = node.getEnd();
-    const head = source.getLineAndCharacterOfPosition(start);
-    const tail = source.getLineAndCharacterOfPosition(end);
-    return {
-      fileName: source.fileName,
-      start,
-      end,
-      line: head.line,
-      character: head.character,
-      endLine: tail.line,
-      endCharacter: tail.character
-    };
-  };
-  const extentOf = (source, node) => ({
-    start: node.getStart(source),
-    end: node.getEnd()
-  });
-  const unwrap = (expression) => {
-    let current = expression;
-    while (ts.isParenthesizedExpression(current) || ts.isAsExpression(current) || ts.isSatisfiesExpression(current))
-      current = current.expression;
-    return current;
-  };
-  const moduleRefOf = (expression, holder) => {
-    let current = expression && unwrap(expression);
-    while (current && ts.isCallExpression(current) && ts.isPropertyAccessExpression(current.expression))
-      current = current.expression.expression;
-    if (current && ts.isStringLiteral(current))
-      return current.text;
-    if (!current || !ts.isPropertyAccessExpression(current))
-      return null;
-    return ts.isIdentifier(current.expression) && current.expression.text === holder ? current.name.text : null;
-  };
-  const returnedObject = (builder) => builder ? ast.firstObjectReturnedByArrow(builder) : null;
-  const builderOf = (call) => [...call.arguments].reverse().find((arg) => ts.isArrowFunction(arg) || ts.isFunctionExpression(arg));
-  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((element) => ast.expressionName(element)).filter((name) => name !== null);
-    if (ts.isObjectLiteralExpression(guards))
-      return guards.properties.filter(ts.isPropertyAssignment).map((property) => `${ast.nodeName(property.name)} ${ast.expressionName(property.initializer) ?? "?"}`);
-    const single = ast.expressionName(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);
-    const methods = [];
-    while (ts.isCallExpression(root) && ts.isPropertyAccessExpression(root.expression) && ts.isCallExpression(unwrap(root.expression.expression))) {
-      methods.push(root.expression.name.text);
-      root = unwrap(root.expression.expression);
-    }
-    return { root: ts.isCallExpression(root) ? root : null, methods };
-  };
-  const keyName = (property) => ts.isPropertyAssignment(property) || ts.isMethodDeclaration(property) || ts.isShorthandPropertyAssignment(property) ? property.name : null;
-  const objectKeys = (source, object) => (object?.properties ?? []).flatMap((property) => {
-    const name = ast.propertyName(property);
-    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) => {
-    if (!ts.isPropertyAssignment(property))
-      return [];
-    const name = ast.nodeName(property.name);
-    if (!name)
-      return [];
-    const { root, methods } = chainOf(property.initializer);
-    return [
-      {
-        name,
-        span: spanOf(source, property.name),
-        extent: extentOf(source, property),
-        guards: root ? guardsIn(optionObjectOf(root)) : [],
-        live: methods.includes("live"),
-        argCount: methods.filter((method) => argMethods.has(method)).length
-      }
-    ];
-  });
-  const verbReaderOf = (parameter) => {
-    const verbs = new Map;
-    if (parameter && ts.isObjectBindingPattern(parameter.name))
-      for (const element of parameter.name.elements) {
-        const verb = element.propertyName ?? element.name;
-        if (ts.isIdentifier(verb) && ts.isIdentifier(element.name))
-          verbs.set(element.name.text, verb.text);
-      }
-    const holder = parameter && ts.isIdentifier(parameter.name) ? parameter.name.text : null;
-    return (callee) => {
-      if (callee && ts.isIdentifier(callee))
-        return verbs.get(callee.text) ?? null;
-      if (callee && ts.isPropertyAccessExpression(callee) && ts.isIdentifier(callee.expression) && callee.expression.text === holder)
-        return callee.name.text;
-      return null;
-    };
-  };
-  const endpointKeysOf = (source, builder) => {
-    const verbOf = verbReaderOf(builder?.parameters[0]);
-    return (returnedObject(builder)?.properties ?? []).flatMap((property) => {
-      if (!ts.isPropertyAssignment(property))
-        return [];
-      const name = ast.nodeName(property.name);
-      if (!name)
-        return [];
-      const { root, methods } = chainOf(property.initializer);
-      return [
-        {
-          name,
-          span: spanOf(source, property.name),
-          extent: extentOf(source, property),
-          verb: root ? verbOf(root.expression) : null,
-          guards: root ? guardsIn(optionObjectOf(root)) : [],
-          argCount: methods.filter((method) => argMethods.has(method)).length
-        }
-      ];
-    });
-  };
-  const filterQueriesOf = (source, builder) => {
-    const query = returnedObject(builder)?.properties.find((property) => ts.isPropertyAssignment(property) && ast.nodeName(property.name) === "query")?.initializer;
-    return query && ts.isObjectLiteralExpression(query) ? objectKeys(source, query) : [];
-  };
-  const typeOf = (expression) => {
-    const value = expression && unwrap(expression);
-    if (value && ts.isArrayLiteralExpression(value))
-      return { type: typeOf(value.elements[0]).type, array: true };
-    return { type: value ? ast.expressionName(value) : null, array: false };
-  };
-  const fieldsOf = (source, object) => (object?.properties ?? []).flatMap((property) => {
-    const name = ast.propertyName(property);
-    const node = keyName(property);
-    if (!name || !node)
-      return [];
-    const { root, methods } = ts.isPropertyAssignment(property) ? chainOf(property.initializer) : { root: null, methods: [] };
-    return [
-      {
-        name,
-        span: spanOf(source, node),
-        extent: extentOf(source, property),
-        ...typeOf(root?.arguments[0]),
-        optional: methods.includes("optional")
-      }
-    ];
-  });
-  const constantOf = (source, name, call) => {
-    const parents = call.arguments.map(unwrap).filter((arg) => ts.isIdentifier(arg) || ts.isPropertyAccessExpression(arg)).map((arg) => ast.expressionName(arg)).filter((parent) => parent !== null);
-    const fields = call.arguments.flatMap((arg) => fieldsOf(source, ast.firstObjectReturnedByArrow(arg)));
-    return { ...name, parents, fields };
-  };
-  const enumValuesOf = (call) => {
-    const list = call.arguments[1] && unwrap(call.arguments[1]);
-    if (!list || !ts.isArrayLiteralExpression(list))
-      return [];
-    return list.elements.flatMap((element) => ts.isStringLiteralLike(element) ? [element.text] : []);
-  };
-  const methodsOf = (source, statement) => statement.members.flatMap((member) => {
-    if (!ts.isMethodDeclaration(member) || !member.body)
-      return [];
-    const name = ast.nodeName(member.name);
-    if (!name || ts.getModifiers(member)?.some(({ kind }) => kind === ts.SyntaxKind.StaticKeyword))
-      return [];
-    return [{ name, span: spanOf(source, member.name), extent: extentOf(source, member) }];
-  });
-  const lowerFirst = (text) => text.charAt(0).toLowerCase() + text.slice(1);
-  const read = (source, owner) => {
-    const facts = {
-      fileName: source.fileName,
-      owner,
-      constants: [],
-      enums: [],
-      filters: [],
-      models: [],
-      services: [],
-      slices: [],
-      endpoints: [],
-      stores: []
-    };
-    for (const statement of source.statements) {
-      if (!ts.isClassDeclaration(statement) || !statement.name)
-        continue;
-      const heritage = ast.heritageCallNamed(statement, moduleCallees);
-      if (!heritage)
+  };
+  const heritageCallNamed = (node, names) => {
+    const heritage = node.heritageClauses?.flatMap((clause) => [...clause.types]) ?? [];
+    for (const { expression } of heritage) {
+      if (!ts.isCallExpression(expression))
         continue;
-      const { callee, call } = heritage;
-      const name = { name: statement.name.text, span: spanOf(source, statement.name) };
-      const builder = builderOf(call);
-      if (callee === "via")
-        facts.constants.push(constantOf(source, name, call));
-      else if (callee === "enumOf")
-        facts.enums.push({ ...name, values: enumValuesOf(call) });
-      else if (callee === "from")
-        facts.filters.push({ ...name, queries: filterQueriesOf(source, builder) });
-      else if (callee === "into")
-        facts.models.push({ ...name, model: name.name.endsWith("Model") ? lowerFirst(name.name.slice(0, -5)) : null });
-      else if (callee === "serve")
-        facts.services.push({
-          ...name,
-          model: moduleRefOf(call.arguments[0], "db"),
-          methods: methodsOf(source, statement)
-        });
-      else if (callee === "slice")
-        facts.slices.push({
-          ...name,
-          model: moduleRefOf(call.arguments[0], "srv"),
-          guards: guardsIn(call.arguments.find(ts.isObjectLiteralExpression)),
-          keys: sliceKeysOf(source, builder)
-        });
-      else if (callee === "endpoint")
-        facts.endpoints.push({
-          ...name,
-          model: moduleRefOf(call.arguments[0], "srv"),
-          keys: endpointKeysOf(source, builder)
-        });
-      else if (callee === "store")
-        facts.stores.push({
-          ...name,
-          model: moduleRefOf(call.arguments[0], "sig"),
-          stateKeys: objectKeys(source, returnedObject(builder)),
-          actions: methodsOf(source, statement)
-        });
+      const callee = expressionName(expression.expression);
+      if (callee && names.has(callee))
+        return { callee, call: expression };
     }
-    return facts;
+    return null;
+  };
+  const viaNames = new Set(["via"]);
+  const heritageCall = (node) => heritageCallNamed(node, viaNames)?.call ?? null;
+  return {
+    sourceFileFor,
+    nodeName,
+    propertyName,
+    expressionName,
+    callExpressionName,
+    firstObjectReturnedByArrow,
+    heritageCallNamed,
+    heritageCall
   };
-  return { read, spanOf, moduleRefOf, chainOf, unwrap };
 };
 
 // pkgs/akanjs/common/capitalize.ts
@@ -1169,6 +1986,7 @@ class NameTable {
 // pkgs/@akanjs/language/akanIndex.ts
 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;
@@ -1204,21 +2022,26 @@ class AkanIndex {
   }
   setFile(givenName, text) {
     const fileName = pathOf(givenName);
-    this.#fileWords.set(fileName, `
+    const words = `
 ${[...new Set(text.match(wordPattern))].join(`
 `)}
-`);
-    if (!AkanIndex.isSourcePath(fileName))
+`;
+    this.#fileWords.set(fileName, words);
+    const isSource = AkanIndex.isSourcePath(fileName);
+    if (!isSource && !AkanIndex.#holdsFacts(fileName, words)) {
+      this.#facts.delete(fileName);
       return;
+    }
     const source = this.#parsed.get(fileName)?.text === text ? this.#parse(fileName, text) : this.#parseUncached(fileName, text);
     this.#facts.set(fileName, this.#reader.read(source, this.#ownerOf(fileName)));
-    this.#table = null;
+    if (isSource)
+      this.#table = null;
   }
   removeFile(givenName) {
     const fileName = pathOf(givenName);
     this.#fileWords.delete(fileName);
     this.#parsed.delete(fileName);
-    if (this.#facts.delete(fileName))
+    if (this.#facts.delete(fileName) && AkanIndex.isSourcePath(fileName))
       this.#table = null;
   }
   definitionAt(givenName, text, offset) {
@@ -1266,7 +2089,8 @@ ${[...new Set(text.match(wordPattern))].join(`
         return site ? this.#resolve(fileName, site) : [];
       },
       relative: (fileName) => this.#relative(fileName),
-      ownerOf: (fileName) => this.#ownerOf(fileName)
+      ownerOf: (fileName) => this.#ownerOf(fileName),
+      reader: this.#reader
     }).build();
   }
   renameTargetAt(givenName, offset) {
@@ -1289,6 +2113,22 @@ ${[...new Set(text.match(wordPattern))].join(`
       }))
     ];
   }
+  static #holdsFacts(fileName, words) {
+    if (testFilePattern.test(fileName))
+      return false;
+    if (srvkitPattern.test(fileName))
+      return true;
+    const holdsGuards = words.includes(`
+Guard
+`) && words.includes(`
+canPass
+`);
+    return holdsGuards || words.includes(`
+adapt
+`) || words.includes(`
+dangerouslyAdapt
+`);
+  }
   static #sourceKeyOf({ family, sourceKey, label, detail, span }) {
     return { family, sourceKey, label, detail, span };
   }
@@ -1379,7 +2219,7 @@ ${dictionary.className}
     return this.#nameTable().entriesTargeting(fileName).filter((entry) => entry.span.start <= offset && offset <= entry.span.end);
   }
   #nameTable() {
-    this.#table ??= new NameTable(this.#facts.values());
+    this.#table ??= new NameTable([...this.#facts.values()].filter(({ fileName }) => AkanIndex.isSourcePath(fileName)));
     return this.#table;
   }
   #relative(fileName) {
@@ -1513,9 +2353,871 @@ ${dictionary.className}
     })).sort((a, b) => Number(b.owner === owner) - Number(a.owner === owner));
   }
 }
+// pkgs/@akanjs/language/frameworkChannelReader.ts
+class FrameworkChannelReader {
+  #ts;
+  #unions = [];
+  #channels = [];
+  #missing = [];
+  #deferred = [];
+  #spoken = new Map;
+  #sendParameters = new Set;
+  #classes = new Map;
+  #injectedSends = [];
+  #constructed = new Map;
+  constructor(ts, specs, sources) {
+    this.#ts = ts;
+    for (const source of sources.values())
+      for (const statement of source.statements)
+        if (ts.isClassDeclaration(statement) && statement.name)
+          this.#classes.set(statement.name.text, [...this.#classes.get(statement.name.text) ?? [], statement]);
+    for (const source of sources.values())
+      this.#unions.push(...this.#unionsIn(source));
+    const parts = new Set(this.#unions.flatMap((union) => [...union.typeNames].filter((name) => name !== union.name).map((name) => `${union.file}
+${name}`)));
+    this.#unions.splice(0, this.#unions.length, ...this.#unions.filter((union) => !parts.has(`${union.file}
+${union.name}`)));
+    for (const spec of specs) {
+      const union = this.#unions.find(({ file, name }) => file === spec.file && name === spec.union);
+      if (!union) {
+        this.#missing.push(`${spec.union} in ${spec.file}`);
+        continue;
+      }
+      union.channel = { spec, union, senders: new Map, handlers: new Map };
+      this.#channels.push(union.channel);
+    }
+    for (const source of sources.values())
+      this.#read(source);
+    for (const { channels, ...site } of this.#deferred) {
+      const spoken = this.#spoken.get(site.source.fileName);
+      for (const channel of channels)
+        if (spoken?.has(channel))
+          this.#record(channel, site);
+    }
+    for (const { owner, ...site } of this.#injectedSends)
+      for (const file of this.#constructed.get(owner) ?? [])
+        for (const channel of [...this.#spoken.get(file) ?? []])
+          if (channel.union.members.has(site.literal) && !this.#holds(channel, site))
+            this.#record(channel, site);
+  }
+  get missing() {
+    return [...this.#missing];
+  }
+  channels() {
+    return this.#channels.map(({ spec, union, senders, handlers }) => ({
+      name: spec.union,
+      label: spec.label,
+      at: union.at,
+      messages: [...union.members].map(([type, member]) => ({
+        type,
+        at: member.at,
+        senders: FrameworkChannelReader.#grouped(senders.get(type) ?? []),
+        handlers: FrameworkChannelReader.#grouped(handlers.get(type) ?? [])
+      }))
+    }));
+  }
+  static #grouped(sites) {
+    const byOwner = new Map;
+    const ordered = [...sites].sort((a, b) => a.at.file === b.at.file ? a.at.line - b.at.line : a.at.file < b.at.file ? -1 : 1);
+    for (const site of ordered) {
+      const existing = byOwner.get(site.owner);
+      if (existing)
+        existing.count += 1;
+      else
+        byOwner.set(site.owner, { ...site, count: 1 });
+    }
+    return [...byOwner.values()].sort((a, b) => a.owner < b.owner ? -1 : a.owner > b.owner ? 1 : 0);
+  }
+  #location(source, node) {
+    const { line, character } = source.getLineAndCharacterOfPosition(node.getStart(source));
+    return { file: source.fileName, line: line + 1, column: character + 1 };
+  }
+  #unionsIn(source) {
+    const ts = this.#ts;
+    const declarations = new Map;
+    for (const statement of source.statements)
+      if (ts.isTypeAliasDeclaration(statement) || ts.isInterfaceDeclaration(statement))
+        declarations.set(statement.name.text, statement);
+    return [...declarations.values()].flatMap((declaration) => {
+      if (!ts.isTypeAliasDeclaration(declaration) || !ts.isUnionTypeNode(declaration.type))
+        return [];
+      const members = new Map;
+      const typeNames = new Set([declaration.name.text]);
+      const isShaped = this.#collect(source, declaration.type, declarations, members, typeNames);
+      if (!isShaped || members.size < 2)
+        return [];
+      return [
+        {
+          file: source.fileName,
+          name: declaration.name.text,
+          at: this.#location(source, declaration.name),
+          members,
+          typeNames,
+          channel: null
+        }
+      ];
+    });
+  }
+  #collect(source, type, declarations, members, typeNames) {
+    const ts = this.#ts;
+    if (ts.isParenthesizedTypeNode(type))
+      return this.#collect(source, type.type, declarations, members, typeNames);
+    if (ts.isUnionTypeNode(type))
+      return type.types.every((member) => this.#collect(source, member, declarations, members, typeNames));
+    if (ts.isTypeLiteralNode(type))
+      return this.#addMember(source, type.members, members);
+    if (!ts.isTypeReferenceNode(type) || !ts.isIdentifier(type.typeName))
+      return false;
+    const name = type.typeName.text;
+    const declaration = declarations.get(name);
+    if (!declaration)
+      return false;
+    if (typeNames.has(name))
+      return true;
+    typeNames.add(name);
+    return ts.isTypeAliasDeclaration(declaration) ? this.#collect(source, declaration.type, declarations, members, typeNames) : this.#addMember(source, declaration.members, members);
+  }
+  #addMember(source, elements, members) {
+    const ts = this.#ts;
+    const typeProperty = elements.find((element) => ts.isPropertySignature(element) && this.#nameOf(element.name) === "type");
+    const literal = typeProperty?.type && ts.isLiteralTypeNode(typeProperty.type) && ts.isStringLiteral(typeProperty.type.literal) ? typeProperty.type.literal.text : null;
+    if (!typeProperty || literal === null)
+      return false;
+    const keys = new Set;
+    const required = new Set;
+    for (const element of elements) {
+      const name = ts.isPropertySignature(element) ? this.#nameOf(element.name) : null;
+      if (!name)
+        continue;
+      keys.add(name);
+      if (ts.isPropertySignature(element) && !element.questionToken)
+        required.add(name);
+    }
+    const existing = members.get(literal);
+    if (!existing) {
+      members.set(literal, { at: this.#location(source, typeProperty), keys, required });
+      return true;
+    }
+    for (const key of keys)
+      existing.keys.add(key);
+    for (const key of existing.required)
+      if (!required.has(key))
+        existing.required.delete(key);
+    return true;
+  }
+  #nameOf(name) {
+    const ts = this.#ts;
+    return ts.isIdentifier(name) || ts.isStringLiteral(name) ? name.text : null;
+  }
+  #literalOf(expression) {
+    const ts = this.#ts;
+    return expression && (ts.isStringLiteral(expression) || ts.isNoSubstitutionTemplateLiteral(expression)) ? expression.text : null;
+  }
+  #record(channel, { role, literal, source, node }) {
+    const sites = channel[role];
+    const site = { owner: this.#ownerOf(source, node), count: 1, at: this.#location(source, node) };
+    const relayed = role === "handlers" && !!site.owner && !!channel.spec.relays?.includes(site.owner);
+    if (!relayed)
+      sites.set(literal, [...sites.get(literal) ?? [], site]);
+    const spoken = this.#spoken.get(source.fileName) ?? new Set;
+    spoken.add(channel);
+    this.#spoken.set(source.fileName, spoken);
+  }
+  #settle(candidates, site) {
+    const local = candidates.filter(({ file }) => file === site.source.fileName);
+    const unions = candidates.length > 1 && local.length ? local : candidates;
+    const channels = unions.flatMap(({ channel }) => channel ? [channel] : []);
+    if (unions.length === 1 && channels.length === 1)
+      this.#record(channels[0], site);
+    else if (channels.length)
+      this.#deferred.push({ ...site, channels });
+  }
+  #ownerOf(source, node) {
+    const ts = this.#ts;
+    let top = node;
+    for (let current = node;current; current = current.parent) {
+      if ((ts.isClassDeclaration(current) || ts.isClassExpression(current)) && current.name)
+        return current.name.text;
+      if (current.parent && !ts.isSourceFile(current.parent))
+        top = current.parent;
+    }
+    if (ts.isFunctionDeclaration(top) && top.name)
+      return top.name.text;
+    if (ts.isVariableStatement(top)) {
+      const declaration = top.declarationList.declarations.find(({ initializer, pos, end }) => !!initializer && (ts.isArrowFunction(initializer) || ts.isFunctionExpression(initializer)) && pos <= node.pos && node.end <= end);
+      if (declaration && ts.isIdentifier(declaration.name))
+        return declaration.name.text;
+    }
+    const classes = source.statements.filter(ts.isClassDeclaration);
+    const only = classes.length === 1 ? classes[0].name?.text : undefined;
+    return only ?? source.fileName.slice(source.fileName.lastIndexOf("/") + 1).replace(/\.tsx?$/, "");
+  }
+  #namesIn(type) {
+    const ts = this.#ts;
+    const names = new Set;
+    const visit = (node) => {
+      if (ts.isTypeReferenceNode(node))
+        names.add(ts.isIdentifier(node.typeName) ? node.typeName.text : node.typeName.right.text);
+      if (!ts.isTypeLiteralNode(node))
+        ts.forEachChild(node, visit);
+    };
+    if (type)
+      visit(type);
+    return names;
+  }
+  #literalTypesIn(type) {
+    const ts = this.#ts;
+    const literals = new Set;
+    const visit = (node) => {
+      if (ts.isLiteralTypeNode(node) && ts.isStringLiteral(node.literal))
+        literals.add(node.literal.text);
+      ts.forEachChild(node, visit);
+    };
+    if (type)
+      visit(type);
+    return literals;
+  }
+  #hinted(names) {
+    return this.#unions.filter((union) => [...names].some((name) => union.typeNames.has(name)));
+  }
+  #read(source) {
+    const ts = this.#ts;
+    const comparisons = new Map;
+    const switches = [];
+    const templates = [];
+    const calls = [];
+    const visit = (node) => {
+      if (ts.isObjectLiteralExpression(node)) {
+        const template = this.#readSend(source, node);
+        if (template)
+          templates.push(template);
+      } else if (ts.isCallExpression(node))
+        calls.push(node);
+      else if (ts.isNewExpression(node)) {
+        this.#readRouteSet(source, node);
+        if (ts.isIdentifier(node.expression)) {
+          const files = this.#constructed.get(node.expression.text) ?? new Set;
+          files.add(source.fileName);
+          this.#constructed.set(node.expression.text, files);
+        }
+      } else if (ts.isSwitchStatement(node)) {
+        const chain = this.#switchChain(node);
+        if (chain)
+          switches.push(chain);
+      } else if (ts.isBinaryExpression(node)) {
+        const compared = this.#comparedType(node);
+        if (compared) {
+          const key = `${this.#scopeOf(node)?.pos ?? -1}:${compared.receiver.getText(source)}`;
+          const chain = comparisons.get(key) ?? {
+            literals: [],
+            hint: this.#declaredTypeNames(compared.receiver),
+            parameter: this.#parameterOf(compared.receiver)
+          };
+          chain.literals.push([compared.literal, compared.at]);
+          comparisons.set(key, chain);
+        }
+      }
+      ts.forEachChild(node, visit);
+    };
+    visit(source);
+    for (const { object, fn, index } of templates)
+      for (const call of calls) {
+        const argument = call.arguments[index];
+        const literal = this.#literalOf(argument);
+        if (literal !== null && this.#calleeOf(call) === fn)
+          this.#sendSite(source, object, literal, argument, true);
+      }
+    for (const chain of [...switches, ...comparisons.values()])
+      if (!chain.parameter || !this.#sendParameters.has(chain.parameter))
+        this.#readChain(source, chain);
+  }
+  #readSend(source, object) {
+    const ts = this.#ts;
+    const typeProperty = object.properties.find((property) => (ts.isPropertyAssignment(property) || ts.isShorthandPropertyAssignment(property)) && this.#nameOf(property.name) === "type");
+    if (!typeProperty)
+      return null;
+    const value = ts.isPropertyAssignment(typeProperty) ? typeProperty.initializer : typeProperty.name;
+    const literal = this.#literalOf(value);
+    if (literal !== null)
+      this.#sendSite(source, object, literal, typeProperty, false);
+    if (literal !== null || !ts.isIdentifier(value))
+      return null;
+    const fn = this.#scopeOf(object);
+    const index = fn?.parameters.findIndex(({ name }) => ts.isIdentifier(name) && name.text === value.text) ?? -1;
+    return fn && index >= 0 ? { object, fn, index } : null;
+  }
+  #sendSite(source, object, literal, node, forwarded) {
+    const context = this.#sendContextOf(object, forwarded ? null : literal);
+    if (!context)
+      return;
+    const site = { role: "senders", literal, source, node };
+    const injector = this.#injectorOf(object);
+    if (injector)
+      this.#injectedSends.push({ ...site, owner: injector });
+    const hinted = this.#hinted(context.names).filter((union) => union.members.has(literal));
+    const candidates = hinted.length ? hinted : this.#fitting(object, literal);
+    if (context.parameter && candidates.some(({ channel }) => channel))
+      this.#sendParameters.add(context.parameter);
+    this.#settle(candidates, site);
+  }
+  #injectorOf(object) {
+    const ts = this.#ts;
+    const call = object.parent;
+    if (!ts.isCallExpression(call) || !call.arguments.includes(object))
+      return null;
+    const callee = call.expression;
+    if (!ts.isPropertyAccessExpression(callee) || callee.expression.kind !== ts.SyntaxKind.ThisKeyword)
+      return null;
+    const owner = this.#classOf(call);
+    const constructor = owner?.members.find(ts.isConstructorDeclaration);
+    const parameters = new Set(constructor?.parameters.flatMap(({ name }) => ts.isIdentifier(name) ? [name.text] : []) ?? []);
+    const isInjected = !!constructor?.body?.statements.some((statement) => {
+      if (!ts.isExpressionStatement(statement) || !ts.isBinaryExpression(statement.expression))
+        return false;
+      const { left, operatorToken, right } = statement.expression;
+      return operatorToken.kind === ts.SyntaxKind.EqualsToken && ts.isPropertyAccessExpression(left) && left.expression.kind === ts.SyntaxKind.ThisKeyword && this.#memberName(left.name) === callee.name.text && ts.isIdentifier(right) && parameters.has(right.text);
+    });
+    return isInjected && owner?.name ? owner.name.text : null;
+  }
+  #holds(channel, site) {
+    const { file, line, column } = this.#location(site.source, site.node);
+    return (channel[site.role].get(site.literal) ?? []).some(({ at }) => at.file === file && at.line === line && at.column === column);
+  }
+  #fitting(object, literal) {
+    const ts = this.#ts;
+    const isLoose = object.properties.some((property) => ts.isSpreadAssignment(property));
+    const keys = new Set(object.properties.flatMap((property) => {
+      const name = ts.isSpreadAssignment(property) ? null : this.#nameOf(property.name);
+      return name === null ? [] : [name];
+    }));
+    return this.#unions.filter((union) => {
+      const member = union.members.get(literal);
+      return !!member && [...keys].every((key) => member.keys.has(key)) && (isLoose || [...member.required].every((key) => keys.has(key)));
+    });
+  }
+  #sendContextOf(object, literal) {
+    const ts = this.#ts;
+    const hint = new Set;
+    let node = object;
+    while (node.parent) {
+      const parent = node.parent;
+      if (ts.isParenthesizedExpression(parent) || ts.isConditionalExpression(parent))
+        node = parent;
+      else if (ts.isAsExpression(parent) || ts.isSatisfiesExpression(parent)) {
+        for (const name of this.#namesIn(parent.type))
+          hint.add(name);
+        node = parent;
+      } else if (ts.isCallExpression(parent) && this.#calleeName(parent) === "stringify")
+        node = parent;
+      else if (ts.isArrowFunction(parent) && parent.body === node && !parent.type)
+        node = parent;
+      else
+        break;
+    }
+    const parent = node.parent;
+    if (!parent)
+      return null;
+    const scope = this.#scopeOf(object);
+    if (literal !== null && scope?.parameters.some(({ type }) => this.#literalTypesIn(type).has(literal)))
+      return null;
+    const context = (names, parameter = null) => ({
+      names: new Set([...hint, ...names]),
+      parameter
+    });
+    if (ts.isCallExpression(parent)) {
+      const index = parent.arguments.indexOf(node);
+      if (index < 0)
+        return null;
+      const parameter = this.#calleeOf(parent)?.parameters[index] ?? null;
+      return context(this.#namesIn(parameter?.type), parameter);
+    }
+    if (ts.isVariableDeclaration(parent) && parent.type)
+      return context(this.#namesIn(parent.type));
+    if (ts.isPropertyAssignment(parent) && ts.isObjectLiteralExpression(parent.parent)) {
+      const outer = this.#sendContextOf(parent.parent, null);
+      const property = this.#nameOf(parent.name);
+      const names = outer && property ? this.#propertyTypeNames(object.getSourceFile(), outer.names, property) : null;
+      return names?.size ? context(names) : null;
+    }
+    const fn = ts.isReturnStatement(parent) ? this.#scopeOf(parent) : ts.isArrowFunction(parent) ? parent : null;
+    if (fn?.type)
+      return context(this.#namesIn(fn.type));
+    return hint.size ? context(new Set) : null;
+  }
+  #propertyTypeNames(source, typeNames, property) {
+    const ts = this.#ts;
+    for (const statement of source.statements) {
+      if (!(ts.isInterfaceDeclaration(statement) || ts.isTypeAliasDeclaration(statement)))
+        continue;
+      if (!typeNames.has(statement.name.text))
+        continue;
+      const members = ts.isInterfaceDeclaration(statement) ? statement.members : ts.isTypeLiteralNode(statement.type) ? statement.type.members : [];
+      const signature = members.find((member) => ts.isPropertySignature(member) && this.#nameOf(member.name) === property);
+      if (signature?.type)
+        return this.#namesIn(signature.type);
+    }
+    return null;
+  }
+  #calleeOf(call) {
+    const ts = this.#ts;
+    const callee = call.expression;
+    const isFunction = (node) => !!node && (ts.isArrowFunction(node) || ts.isFunctionExpression(node));
+    if (ts.isPropertyAccessExpression(callee) && callee.expression.kind === ts.SyntaxKind.ThisKeyword) {
+      const member = this.#memberOf(this.#classOf(call), callee.name.text);
+      if (!member)
+        return null;
+      if (ts.isMethodDeclaration(member))
+        return member;
+      return ts.isPropertyDeclaration(member) && isFunction(member.initializer) ? member.initializer : null;
+    }
+    if (ts.isPropertyAccessExpression(callee)) {
+      for (const name of this.#receiverTypeNames(callee.expression))
+        for (const declaration of this.#classes.get(name) ?? []) {
+          const member = this.#memberOf(declaration, callee.name.text);
+          if (member && ts.isMethodDeclaration(member))
+            return member;
+        }
+      return null;
+    }
+    if (!ts.isIdentifier(callee))
+      return null;
+    for (const statement of call.getSourceFile().statements) {
+      if (ts.isFunctionDeclaration(statement) && statement.name?.text === callee.text)
+        return statement;
+      if (!ts.isVariableStatement(statement))
+        continue;
+      for (const declaration of statement.declarationList.declarations)
+        if (ts.isIdentifier(declaration.name) && declaration.name.text === callee.text)
+          return isFunction(declaration.initializer) ? declaration.initializer : null;
+    }
+    return null;
+  }
+  #classOf(node) {
+    let owner = node.parent;
+    while (owner && !this.#ts.isClassLike(owner))
+      owner = owner.parent;
+    return owner ?? null;
+  }
+  #memberOf(owner, name) {
+    return owner?.members.find((member) => member.name && this.#memberName(member.name) === name) ?? null;
+  }
+  #receiverTypeNames(receiver) {
+    const ts = this.#ts;
+    if (ts.isPropertyAccessExpression(receiver) && receiver.expression.kind === ts.SyntaxKind.ThisKeyword) {
+      const field = this.#memberOf(this.#classOf(receiver), receiver.name.text);
+      return field && ts.isPropertyDeclaration(field) ? this.#namesIn(field.type) : new Set;
+    }
+    return this.#declaredTypeNames(receiver) ?? new Set;
+  }
+  #memberName(name) {
+    const ts = this.#ts;
+    return ts.isIdentifier(name) || ts.isPrivateIdentifier(name) || ts.isStringLiteral(name) ? name.text : null;
+  }
+  #calleeName(call) {
+    const ts = this.#ts;
+    const callee = call.expression;
+    if (ts.isIdentifier(callee))
+      return callee.text;
+    if (ts.isPropertyAccessExpression(callee))
+      return callee.name.text;
+    return null;
+  }
+  #scopeOf(node) {
+    const ts = this.#ts;
+    for (let current = node.parent;current; current = current.parent)
+      if (ts.isFunctionLike(current))
+        return current;
+    return null;
+  }
+  #typeReceiverOf(expression) {
+    const ts = this.#ts;
+    if (ts.isPropertyAccessExpression(expression) && expression.name.text === "type")
+      return expression.expression;
+    if (ts.isElementAccessExpression(expression) && this.#literalOf(expression.argumentExpression) === "type")
+      return expression.expression;
+    return null;
+  }
+  #comparedType(node) {
+    const ts = this.#ts;
+    const { kind } = node.operatorToken;
+    if (kind !== ts.SyntaxKind.EqualsEqualsEqualsToken && kind !== ts.SyntaxKind.ExclamationEqualsEqualsToken && kind !== ts.SyntaxKind.EqualsEqualsToken && kind !== ts.SyntaxKind.ExclamationEqualsToken)
+      return null;
+    for (const [side, other] of [
+      [node.left, node.right],
+      [node.right, node.left]
+    ]) {
+      const receiver = this.#typeReceiverOf(side);
+      const literal = this.#literalOf(other);
+      if (receiver && literal !== null)
+        return { receiver, literal, at: other };
+    }
+    return null;
+  }
+  #declaredTypeNames(receiver) {
+    const ts = this.#ts;
+    if (!ts.isIdentifier(receiver))
+      return null;
+    const name = receiver.text;
+    for (let current = receiver.parent;current; current = current.parent) {
+      if (ts.isFunctionLike(current)) {
+        for (const parameter of current.parameters)
+          if (ts.isIdentifier(parameter.name) && parameter.name.text === name)
+            return parameter.type ? this.#namesIn(parameter.type) : null;
+      }
+      if (ts.isBlock(current) || ts.isSourceFile(current) || ts.isCaseClause(current))
+        for (const statement of current.statements) {
+          if (!ts.isVariableStatement(statement))
+            continue;
+          for (const declaration of statement.declarationList.declarations) {
+            if (!ts.isIdentifier(declaration.name) || declaration.name.text !== name)
+              continue;
+            const { initializer } = declaration;
+            const asType = initializer && (ts.isAsExpression(initializer) || ts.isSatisfiesExpression(initializer)) ? initializer.type : undefined;
+            const type = declaration.type ?? asType;
+            return type ? this.#namesIn(type) : null;
+          }
+        }
+    }
+    return null;
+  }
+  #parameterOf(receiver) {
+    const ts = this.#ts;
+    if (!ts.isIdentifier(receiver))
+      return null;
+    for (let current = receiver.parent;current; current = current.parent)
+      if (ts.isFunctionLike(current)) {
+        const parameter = current.parameters.find(({ name }) => ts.isIdentifier(name) && name.text === receiver.text);
+        if (parameter)
+          return parameter;
+      }
+    return null;
+  }
+  #readChain(source, { literals, hint }) {
+    const hinted = hint?.size ? this.#hinted(hint) : [];
+    if (hint?.size && !hinted.length)
+      return;
+    const scored = this.#unions.map((union) => ({ union, hits: literals.filter(([literal]) => union.members.has(literal)).length })).filter(({ hits }) => hits > 0);
+    const best = Math.max(0, ...scored.map(({ hits }) => hits));
+    const unions = hinted.length ? hinted : best * 2 >= literals.length ? scored.filter(({ hits }) => hits === best).map(({ union }) => union) : [];
+    for (const [literal, node] of literals) {
+      const holding = unions.filter((union) => union.members.has(literal));
+      this.#settle(holding, { role: "handlers", literal, source, node });
+    }
+  }
+  #switchChain(statement) {
+    const ts = this.#ts;
+    const receiver = this.#typeReceiverOf(statement.expression);
+    if (!receiver)
+      return null;
+    const literals = statement.caseBlock.clauses.flatMap((clause) => {
+      if (!ts.isCaseClause(clause))
+        return [];
+      const literal = this.#literalOf(clause.expression);
+      return literal === null ? [] : [[literal, clause.expression]];
+    });
+    return { literals, hint: this.#declaredTypeNames(receiver), parameter: this.#parameterOf(receiver) };
+  }
+  #readRouteSet(source, expression) {
+    const ts = this.#ts;
+    if (!ts.isIdentifier(expression.expression) || expression.expression.text !== "Set")
+      return;
+    const unions = this.#hinted(this.#namesIn(expression.typeArguments?.[0]));
+    const list = expression.arguments?.[0];
+    if (!unions.length || !list || !ts.isArrayLiteralExpression(list))
+      return;
+    for (const element of list.elements) {
+      const literal = this.#literalOf(element);
+      if (literal === null)
+        continue;
+      const holding = unions.filter((union) => union.members.has(literal));
+      this.#settle(holding, { role: "handlers", literal, source, node: element });
+    }
+  }
+}
+// pkgs/@akanjs/language/frameworkMapBuilder.ts
+var extensions = ["", ".ts", ".tsx", "/index.ts", "/index.tsx"];
+var byText = (a, b) => a < b ? -1 : a > b ? 1 : 0;
+
+class FrameworkMapBuilder {
+  #source;
+  #fileSet;
+  constructor(source) {
+    this.#source = source;
+    this.#fileSet = new Set(source.files.map(([file]) => file));
+  }
+  static isSourcePath(file) {
+    return /\.tsx?$/.test(file) && !/\.d\.ts$|\.(?:test|spec)\.tsx?$|fixture/i.test(file);
+  }
+  build() {
+    const { ts, packages, files, channels } = this.#source;
+    const sources = new Map;
+    for (const [file, text] of [...files].sort(([a], [b]) => byText(a, b)))
+      sources.set(file, ts.createSourceFile(file, text, ts.ScriptTarget.Latest, true, file.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS));
+    const facets = new Map;
+    const imports = new Map;
+    for (const [file, source] of sources) {
+      const facet = this.#facetOf(file);
+      if (!facet)
+        continue;
+      const pkg = this.#packageOf(file);
+      const current = facets.get(facet) ?? {
+        id: facet,
+        name: pkg?.split ? facet.slice(pkg.name.length + 1) : facet,
+        packageName: pkg?.name ?? facet,
+        layer: 0,
+        files: 0,
+        classes: []
+      };
+      current.files += 1;
+      current.classes.push(...this.#classesOf(source));
+      facets.set(facet, current);
+      for (const site of this.#importsOf(file, source)) {
+        if (site.facet === facet)
+          continue;
+        const key = `${facet}
+${site.facet}`;
+        const entry = imports.get(key) ?? { from: facet, to: site.facet, value: 0, type: 0, dynamic: 0, at: site.at };
+        if (entry.value === 0 && site.kind === "value" && imports.has(key))
+          entry.at = site.at;
+        entry[site.kind] += 1;
+        imports.set(key, entry);
+      }
+    }
+    const { layerOf, cycles } = FrameworkMapBuilder.#layersOf([...imports.values()]);
+    for (const facet of facets.values()) {
+      facet.classes.sort((a, b) => b.members - a.members || byText(a.name, b.name));
+      facet.layer = layerOf(facet.id);
+    }
+    const reader = new FrameworkChannelReader(ts, channels, sources);
+    return {
+      version: 1,
+      packages: packages.map(({ name, root }) => ({ name, root })),
+      facets: [...facets.values()].sort((a, b) => byText(a.id, b.id)),
+      imports: [...imports.values()].sort((a, b) => byText(a.from, b.from) || byText(a.to, b.to)),
+      channels: reader.channels(),
+      missing: reader.missing,
+      cycles
+    };
+  }
+  static #layersOf(imports) {
+    const deps = new Map;
+    for (const { from, to, value, dynamic } of imports)
+      if (value + dynamic > 0)
+        deps.set(from, [...deps.get(from) ?? [], to]);
+    const components = FrameworkMapBuilder.#stronglyConnected(deps);
+    const componentOf = new Map(components.flatMap((component) => component.map((id) => [id, component])));
+    const layers = new Map;
+    const layerOf = (id) => {
+      const component = componentOf.get(id);
+      if (!component)
+        return 0;
+      const known = layers.get(component);
+      if (known !== undefined)
+        return known;
+      const below = component.flatMap((member) => (deps.get(member) ?? []).filter((to) => !component.includes(to)));
+      const layer = Math.max(-1, ...below.map(layerOf)) + 1;
+      layers.set(component, layer);
+      return layer;
+    };
+    const cycles = components.filter((component) => component.length > 1).map((component) => [...component].sort(byText)).sort((a, b) => byText(a[0], b[0]));
+    return { layerOf, cycles };
+  }
+  static #stronglyConnected(deps) {
+    const ids = [...new Set([...deps.keys(), ...[...deps.values()].flat()])].sort(byText);
+    const index = new Map;
+    const low = new Map;
+    const stack = [];
+    const onStack = new Set;
+    const components = [];
+    const visit = (id) => {
+      index.set(id, index.size);
+      low.set(id, index.get(id) ?? 0);
+      stack.push(id);
+      onStack.add(id);
+      for (const to of deps.get(id) ?? []) {
+        if (!index.has(to)) {
+          visit(to);
+          low.set(id, Math.min(low.get(id) ?? 0, low.get(to) ?? 0));
+        } else if (onStack.has(to))
+          low.set(id, Math.min(low.get(id) ?? 0, index.get(to) ?? 0));
+      }
+      if (low.get(id) !== index.get(id))
+        return;
+      const component = [];
+      for (let member = stack.pop();member !== undefined; member = stack.pop()) {
+        onStack.delete(member);
+        component.push(member);
+        if (member === id)
+          break;
+      }
+      components.push(component);
+    };
+    for (const id of ids)
+      if (!index.has(id))
+        visit(id);
+    return components;
+  }
+  #packageOf(file) {
+    return this.#source.packages.filter(({ root }) => file.startsWith(`${root}/`)).sort((a, b) => b.root.length - a.root.length)[0];
+  }
+  #facetOf(file) {
+    const pkg = this.#packageOf(file);
+    if (!pkg)
+      return null;
+    if (!pkg.split)
+      return pkg.name;
+    const rest = file.slice(pkg.root.length + 1);
+    const slash = rest.indexOf("/");
+    return slash < 0 ? null : `${pkg.name}/${rest.slice(0, slash)}`;
+  }
+  #location(source, node) {
+    const { line, character } = source.getLineAndCharacterOfPosition(node.getStart(source));
+    return { file: source.fileName, line: line + 1, column: character + 1 };
+  }
+  #classesOf(source) {
+    const { ts } = this.#source;
+    return source.statements.flatMap((statement) => ts.isClassDeclaration(statement) && statement.name ? [{ name: statement.name.text, members: statement.members.length, at: this.#location(source, statement.name) }] : []);
+  }
+  #importsOf(file, source) {
+    const { ts } = this.#source;
+    const sites = [];
+    const push = (specifier, kind, node) => {
+      const target = this.#resolve(file, specifier);
+      const facet = target ? this.#facetOf(target) : null;
+      if (facet)
+        sites.push({ facet, kind, at: this.#location(source, node) });
+    };
+    const visit = (node) => {
+      if (ts.isImportDeclaration(node) && ts.isStringLiteral(node.moduleSpecifier)) {
+        const clause = node.importClause;
+        const named = clause?.namedBindings;
+        const isTypeOnly = !!clause?.isTypeOnly || !!clause && !clause.name && !!named && ts.isNamedImports(named) && named.elements.length > 0 && named.elements.every((element) => element.isTypeOnly);
+        push(node.moduleSpecifier.text, isTypeOnly ? "type" : "value", node);
+      } else if (ts.isExportDeclaration(node) && node.moduleSpecifier && ts.isStringLiteral(node.moduleSpecifier)) {
+        const clause = node.exportClause;
+        const isTypeOnly = node.isTypeOnly || !!clause && ts.isNamedExports(clause) && clause.elements.length > 0 && clause.elements.every((element) => element.isTypeOnly);
+        push(node.moduleSpecifier.text, isTypeOnly ? "type" : "value", node);
+      } else if (ts.isCallExpression(node) && node.expression.kind === ts.SyntaxKind.ImportKeyword && node.arguments[0] && ts.isStringLiteralLike(node.arguments[0]))
+        push(node.arguments[0].text, "dynamic", node);
+      ts.forEachChild(node, visit);
+    };
+    visit(source);
+    return sites;
+  }
+  #resolve(file, specifier) {
+    const pkg = specifier.startsWith(".") ? null : this.#source.packages.filter(({ name }) => specifier === name || specifier.startsWith(`${name}/`)).sort((a, b) => b.name.length - a.name.length)[0];
+    if (!specifier.startsWith(".") && !pkg)
+      return null;
+    const base = pkg ? `${pkg.root}${specifier.slice(pkg.name.length)}` : FrameworkMapBuilder.#normalize(`${file.slice(0, file.lastIndexOf("/"))}/${specifier}`);
+    return extensions.map((extension) => `${base}${extension}`).find((candidate) => this.#fileSet.has(candidate)) ?? null;
+  }
+  static #normalize(path) {
+    const parts = [];
+    for (const part of path.split("/"))
+      if (part === "..")
+        parts.pop();
+      else if (part !== "." && part !== "")
+        parts.push(part);
+    return parts.join("/");
+  }
+}
+// pkgs/@akanjs/language/frameworkMapDoc.ts
+var startMarker = "<!-- akan:framework-map:start -->";
+var endMarker = "<!-- akan:framework-map:end -->";
+var citedPattern = /`([A-Z][a-z][A-Za-z0-9]*)(?:[.#][\w$#]+)?(?:\(\))?`/g;
+
+class FrameworkMapDoc {
+  static regenerate = "bun run akan sync-architecture";
+  static render(map, docDir) {
+    const nameOf = new Map(map.facets.map((facet) => [facet.id, facet.name]));
+    const facets = [...map.facets].sort((a, b) => a.layer - b.layer || (a.id < b.id ? -1 : 1));
+    const list = (names) => names.length ? names.join(", ") : "—";
+    const importsOf = (facet, kind) => map.imports.filter(({ from, value, type, dynamic }) => from === facet.id && (kind === "value" ? value + dynamic > 0 : type > 0 && value + dynamic === 0)).map(({ to, value }) => `\`${nameOf.get(to) ?? to}\`${kind === "value" && value === 0 ? " (lazy)" : ""}`);
+    const lines = [
+      startMarker,
+      `<!-- Generated from the framework source by \`${FrameworkMapDoc.regenerate}\`. Edit outside the markers. -->`,
+      "<!-- Outside the markers, every backticked PascalCase name must be a framework class or channel. -->",
+      "",
+      "## Facet layers",
+      "",
+      "A facet loads values only from facets in lower layers. A type-only import loads nothing, so it may point anywhere.",
+      "",
+      "| Layer | Facet | Loads values from | Imports only types from |",
+      "| --- | --- | --- | --- |",
+      ...facets.map((facet) => `| ${facet.layer} | \`${facet.name}\` | ${list(importsOf(facet, "value"))} | ${list(importsOf(facet, "type"))} |`),
+      ...map.cycles.length ? [
+        "",
+        `Facets that load values from each other: ${map.cycles.map((cycle) => cycle.map((id) => `\`${nameOf.get(id) ?? id}\``).join(" ⇄ ")).join("; ")}.`
+      ] : [],
+      "",
+      "## Process messages",
+      "",
+      "Each channel is a union of messages told apart by `type`. A sender writes the message's `type` literal; a handler",
+      "branches on it or relays it. Both are named by the class or top-level function they sit in. A dash means no site",
+      "was recognised.",
+      ...map.channels.flatMap((channel) => {
+        const declared = FrameworkMapDoc.#relative(docDir, channel.at.file);
+        return [
+          "",
+          `### \`${channel.name}\`: ${channel.label}`,
+          "",
+          `Declared in [${declared}](${declared}).`,
+          "",
+          "| Message | Sent by | Handled by |",
+          "| --- | --- | --- |",
+          ...channel.messages.map(({ type, senders, handlers }) => `| \`${type}\` | ${FrameworkMapDoc.#owners(senders)} | ${FrameworkMapDoc.#owners(handlers)} |`)
+        ];
+      }),
+      ...map.missing.length ? ["", `Channels not found: ${map.missing.join("; ")}.`] : [],
+      endMarker
+    ];
+    return lines.join(`
+`);
+  }
+  static generatedOf(markdown) {
+    const start = markdown.indexOf(startMarker);
+    const end = markdown.indexOf(endMarker, start);
+    return start < 0 || end < 0 ? null : markdown.slice(start, end + endMarker.length);
+  }
+  static splice(markdown, generated) {
+    const current = FrameworkMapDoc.generatedOf(markdown);
+    if (current !== null)
+      return markdown.replace(current, () => generated);
+    return `${markdown.trimEnd()}
+
+${generated}
+`;
+  }
+  static citedClasses(markdown) {
+    const current = FrameworkMapDoc.generatedOf(markdown);
+    const handKept = current === null ? markdown : markdown.replace(current, "");
+    return [...new Set([...handKept.matchAll(citedPattern)].map(([, name]) => name))].sort();
+  }
+  static unknownClasses(markdown, map) {
+    const known = new Set([
+      ...map.facets.flatMap(({ classes }) => classes.map(({ name }) => name)),
+      ...map.channels.map(({ name }) => name)
+    ]);
+    return FrameworkMapDoc.citedClasses(markdown).filter((name) => !known.has(name));
+  }
+  static #owners(sites) {
+    return sites.length ? sites.map(({ owner }) => `\`${owner}\``).join(", ") : "—";
+  }
+  static #relative(fromDir, file) {
+    const from = fromDir.split("/").filter(Boolean);
+    const to = file.split("/").filter(Boolean);
+    let shared = 0;
+    while (shared < from.length && shared < to.length - 1 && from[shared] === to[shared])
+      shared += 1;
+    return [...from.slice(shared).map(() => ".."), ...to.slice(shared)].join("/");
+  }
+}
 export {
   AkanGraphDiff,
   AkanIndex,
+  FrameworkChannelReader,
+  FrameworkMapBuilder,
+  FrameworkMapDoc,
   createAst,
   createFactReader,
   ownerOf