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

package/server.js

@@ -0,0 +1,2730 @@
+#!/usr/bin/env node
+
+// pkgs/@akanjs/language/akanLanguageServer.ts
+import { existsSync, readdirSync, readFileSync, realpathSync, statSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+// 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);
+var memberSourcePattern = /\.(signal|service|store)\.ts$/;
+var skippedPattern = /(?:\.(?:constant|document|dictionary|test|spec)\.tsx?|\/lib\/(?:cnst|db|dict|sig|srv|st|useClient|useServer)\.ts|\/index\.tsx?|^(?:apps|libs)\/[^/]+\/(?:client|server)\.ts)$/;
+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;
+  #nodes = new Map;
+  #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;
+    const constantsByOwner = new Map;
+    for (const file of facts)
+      constantsByOwner.set(file.owner, [...constantsByOwner.get(file.owner) ?? [], ...file.constants]);
+    const scopeOf = (owner) => [
+      ...constantsByOwner.get(owner) ?? [],
+      ...[...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];
+      const scalarClass = scalar ? file.constants.find((constant) => constant.name === capitalize(scalar)) : undefined;
+      if (scalar && scalarClass) {
+        const id = this.#key("scalar", owner, scalar);
+        const node = this.#addNode(id, "scalar", owner, scalar, scalarClass.name, scalarClass.span);
+        node.fields = this.#fieldsOf(scalarClass, scopeOf(owner));
+        typed.push(node);
+      }
+      for (const item of file.enums) {
+        const id = this.#key("enum", owner, item.name);
+        this.#addNode(id, "enum", owner, this.#moduleDirOf(file.fileName), item.name, item.span).values = item.values;
+      }
+    }
+    for (const file of facts) {
+      const { owner } = file;
+      for (const service of file.services) {
+        const refName = service.model;
+        if (!refName)
+          continue;
+        const modelId = this.#key("model", owner, refName);
+        const modelClass = constantsByOwner.get(owner)?.find((constant) => constant.name === capitalize(refName));
+        if (modelClass && !this.#nodes.has(modelId)) {
+          const node = this.#addNode(modelId, "model", owner, refName, modelClass.name, modelClass.span);
+          node.fields = this.#fieldsOf(modelClass, scopeOf(owner));
+          typed.push(node);
+        }
+        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"))
+          continue;
+        const refName = lowerFirst(filter.name.slice(0, -"Filter".length));
+        this.#addNode(this.#key("query", owner, refName), "query", owner, refName, "", filter.span);
+        for (const query of filter.queries)
+          this.#digest(this.#addNode(this.#key("query", owner, refName, query.name), "query", owner, refName, query.name, query.span), this.#source.readText(file.fileName), query.extent);
+      }
+      for (const slice of file.slices) {
+        const refName = slice.model;
+        if (!refName)
+          continue;
+        const fallback = this.#addNode(this.#key("slice", owner, refName), "slice", owner, refName, "", slice.span, slice.guards);
+        for (const guard of slice.guards)
+          this.#guard(fallback, guard, file);
+        for (const key of slice.keys) {
+          const detail = [...key.guards, ...key.live ? ["live"] : []];
+          const node = this.#addMember("slice", owner, refName, key, `${refName}.${key.name}`, file.fileName, detail);
+          for (const guard of key.guards)
+            this.#guard(node, guard, file);
+        }
+      }
+      for (const endpoint of file.endpoints) {
+        const refName = endpoint.model;
+        if (!refName)
+          continue;
+        for (const key of endpoint.keys) {
+          const detail = [...key.verb ? [key.verb] : [], ...key.guards];
+          const node = this.#addMember("endpoint", owner, refName, key, `${refName}.${key.name}`, file.fileName, detail);
+          for (const guard of key.guards)
+            this.#guard(node, guard, file);
+        }
+      }
+      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)
+            this.#addMember("action", owner, store.model, action, `${store.name}.${action.name}`, file.fileName);
+    }
+    const types = new Map;
+    for (const node of this.#nodes.values())
+      if (typeKinds.has(node.kind))
+        types.set(node.label, [...types.get(node.label) ?? [], node]);
+    for (const node of typed)
+      for (const field of node.fields ?? []) {
+        const candidates = (field.type ? types.get(field.type) ?? [] : []).filter((type) => this.#visible(type.owner, node.owner));
+        field.ref = (candidates.find((type) => type.owner === node.owner) ?? candidates[0])?.id ?? null;
+        if (field.ref)
+          this.#addEdge(node.id, field.ref, "field", `${field.name}${field.array ? "[]" : ""}`, field.at);
+      }
+    this.#addRoutes();
+    for (const [fileName, words] of this.#source.files)
+      this.#walk(fileName, words);
+    return {
+      version: 1,
+      nodes: [...this.#nodes.values()].sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0),
+      edges: [...this.#edges.values()]
+    };
+  }
+  #key(kind, owner, scope, name = "") {
+    return `${kind}:${owner ?? ""}:${scope}${name ? `.${name}` : ""}`;
+  }
+  #location(span) {
+    return { file: this.#source.relative(span.fileName), line: span.line + 1, column: span.character + 1 };
+  }
+  #addNode(id, kind, owner, module, name, span, detail = [], label = (kind === "query" || kind === "slice") && module ? `${module}${name ? `.${name}` : " (default)"}` : name) {
+    const existing = this.#nodes.get(id);
+    if (existing)
+      return existing;
+    const node = {
+      id,
+      kind,
+      name,
+      label,
+      owner,
+      module,
+      detail,
+      at: span ? this.#location(span) : null
+    };
+    this.#nodes.set(id, node);
+    return node;
+  }
+  #addMember(kind, owner, refName, member, label, fileName, detail = []) {
+    const id = this.#key(kind, owner, refName, member.name);
+    const node = this.#addNode(id, kind, owner, refName, member.name, member.span, detail, label);
+    this.#digest(node, this.#source.readText(fileName), member.extent);
+    this.#contexts.set(fileName, [
+      ...this.#contexts.get(fileName) ?? [],
+      { id, kind, owner, module: refName, extent: member.extent }
+    ]);
+    const byName = `${kind}:${member.name}`;
+    this.#members.set(byName, [...this.#members.get(byName) ?? [], node]);
+    return node;
+  }
+  #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;
+    };
+    for (const { fact, node } of routes) {
+      const parent = parentOf(fact);
+      if (parent)
+        this.#addEdge(parent.id, node.id, "wraps", null, node.at);
+    }
+  }
+  #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;
+    return node.id;
+  }
+  #ownerOfSpecifier(fileName, specifier) {
+    if (frameworkPattern.test(specifier))
+      return frameworkOwner;
+    const path = this.#pathOfSpecifier(fileName, specifier);
+    return path === null ? undefined : ownerOf(path) ?? undefined;
+  }
+  #pathOfSpecifier(fileName, specifier) {
+    const alias = specifier.match(aliasPattern);
+    if (alias)
+      return `${alias[1]}/${alias[2]}${specifier.slice(alias[0].length)}`;
+    if (!specifier.startsWith("."))
+      return null;
+    const segments = this.#source.relative(fileName).split("/").slice(0, -1);
+    for (const segment of specifier.split("/"))
+      if (segment === "..")
+        segments.pop();
+      else if (segment !== ".")
+        segments.push(segment);
+    return segments.join("/");
+  }
+  #moduleDirOf(fileName) {
+    const dir = this.#source.relative(fileName).match(moduleDirPattern)?.[1] ?? null;
+    return dir?.startsWith("_") && !dir.startsWith("__") ? dir.slice(1) : dir;
+  }
+  #fieldsOf(constant, scope) {
+    const fields = new Map;
+    const seen = new Set;
+    const visit = (current) => {
+      if (seen.has(current))
+        return;
+      seen.add(current);
+      for (const parent of current.parents) {
+        const parentClass = scope.find((other) => other.name === parent && other.span.fileName === current.span.fileName) ?? scope.find((other) => other.name === parent);
+        if (parentClass)
+          visit(parentClass);
+      }
+      for (const field of current.fields) {
+        if (fields.has(field.name))
+          continue;
+        const digest = this.#hashOf([this.#source.readText(field.span.fileName), field.extent]);
+        fields.set(field.name, {
+          name: field.name,
+          type: field.type,
+          array: field.array,
+          optional: field.optional,
+          ref: null,
+          declaredIn: current.name,
+          at: this.#location(field.span),
+          ...digest ? { digest } : {}
+        });
+      }
+    };
+    visit(constant);
+    return [...fields.values()];
+  }
+  #visible(target, from) {
+    return !from || !target || target === from || target.startsWith("libs/");
+  }
+  #soleVisible(declared, from) {
+    const visible = declared.filter((other) => this.#visible(other.owner, from));
+    return visible.length === 1 ? visible[0] : undefined;
+  }
+  #targetNodeOf({ family, owner, refName, sourceKey }) {
+    const isDefault = /^[A-Z]/.test(sourceKey);
+    const id = family === "slice" || family === "query" ? this.#key(family, owner, refName, isDefault ? "" : sourceKey) : family === "model" || family === "formSetter" ? this.#key("model", owner, refName) : family === "endpoint" ? this.#key("endpoint", owner, refName, sourceKey) : null;
+    return id && this.#nodes.has(id) ? id : null;
+  }
+  #membersNamed(kind, name, owner, refName) {
+    const nodes = (this.#members.get(`${kind}:${name}`) ?? []).filter((node) => (!refName || node.module === refName) && this.#visible(node.owner, owner));
+    const own = nodes.filter((node) => node.owner === owner);
+    return (own.length ? own : nodes).map((node) => node.id);
+  }
+  #plainTargetsOf(chain, name, context, owner) {
+    const [head, second] = chain ?? [];
+    if (chain?.length === 1 && head === "fetch")
+      return this.#membersNamed("endpoint", name, owner);
+    if (chain?.length === 2 && head === "st" && second === "do")
+      return this.#membersNamed("action", name, owner);
+    if (chain?.length === 1 && head === "this" && (context.kind === "method" || context.kind === "action"))
+      return this.#membersNamed(context.kind, name, context.owner, context.module).filter((id) => id.startsWith(`${context.kind}:${context.owner ?? ""}:`));
+    if (chain?.length === 2 && head === "this" && second && /.Service$/.test(second))
+      return this.#membersNamed("method", name, owner, second.slice(0, -"Service".length));
+    return [];
+  }
+  #walk(fileName, words) {
+    const relative = this.#source.relative(fileName);
+    const contexts = this.#contexts.get(fileName);
+    const isComponentFile = !memberSourcePattern.test(fileName) && !skippedPattern.test(relative) && (words.includes(`
+fetch
+`) || words.includes(`
+st
+`));
+    if (!contexts && !isComponentFile)
+      return;
+    const text = this.#source.readText(fileName);
+    if (text === undefined)
+      return;
+    const { ts } = this.#source;
+    const owner = this.#source.ownerOf(fileName);
+    const source = this.#source.parse(fileName, text);
+    const visit = (node) => {
+      if (ts.isPropertyAccessExpression(node) && ts.isIdentifier(node.name)) {
+        const start = node.name.getStart(source);
+        const chain = this.#chainOf(node.expression);
+        const context = contexts ? contexts.find(({ extent }) => extent.start <= start && start < extent.end) : chain && clientRoots.has(chain[0]) ? this.#componentOf(source, node) : undefined;
+        if (context)
+          this.#link(fileName, source, node.name, chain, context, owner);
+      }
+      ts.forEachChild(node, visit);
+    };
+    visit(source);
+  }
+  #link(fileName, source, identifier, chain, context, owner) {
+    const plugged = chain?.length === 2 && chain[0] === "this" && context.kind === "method" && this.#isServiceThis(identifier) ? this.#plugs.get(`${context.owner ?? ""}
+${context.module}
+${chain[1]}`) : undefined;
+    const resolved = plugged ? [plugged] : this.#source.resolve(fileName, identifier).map((target) => this.#targetNodeOf(target)).filter((id) => id !== null);
+    const targets = resolved.length ? resolved : this.#plainTargetsOf(chain, identifier.text, context, owner);
+    if (!targets.length)
+      return;
+    if (context.pending && !this.#nodes.has(context.id)) {
+      this.#nodes.set(context.id, context.pending);
+      this.#digest(context.pending, source.text, context.extent);
+    }
+    const own = targets.filter((id) => this.#nodes.get(id)?.owner === owner);
+    const kind = context.kind === "component" ? "uses" : chain?.[0] === "fetch" ? "fetches" : "calls";
+    const position = source.getLineAndCharacterOfPosition(identifier.getStart(source));
+    const at = { file: this.#source.relative(fileName), line: position.line + 1, column: position.character + 1 };
+    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))
+      return this.#chainOf(expression.expression);
+    if (ts.isIdentifier(expression))
+      return [expression.text];
+    if (expression.kind === ts.SyntaxKind.ThisKeyword)
+      return ["this"];
+    if (!ts.isPropertyAccessExpression(expression))
+      return null;
+    const head = this.#chainOf(expression.expression);
+    return head ? [...head, expression.name.text] : null;
+  }
+  #componentOf(source, node) {
+    const { ts } = this.#source;
+    let top = node;
+    while (top.parent && !ts.isSourceFile(top.parent))
+      top = top.parent;
+    const declared = ts.isVariableStatement(top) ? top.declarationList.declarations[0]?.name : ts.isFunctionDeclaration(top) || ts.isClassDeclaration(top) ? top.name : undefined;
+    const isDefaultExport = ts.canHaveModifiers(top) && !!ts.getModifiers(top)?.some(({ kind }) => kind === ts.SyntaxKind.DefaultKeyword);
+    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 };
+    if (this.#nodes.has(id))
+      return context;
+    const pagePrefix = owner ? `${owner}/page/` : null;
+    const route = pagePrefix && relative.startsWith(pagePrefix) ? relative.slice(pagePrefix.length).replace(/\.tsx?$/, "") : null;
+    const base = relative.slice(relative.lastIndexOf("/") + 1).replace(/\.tsx?$/, "");
+    const label = route ? `${route}${name === "default" ? "" : `#${name}`}` : name === "default" ? base : `${base}.${name}`;
+    const position = source.getLineAndCharacterOfPosition((declared ?? top).getStart(source));
+    context.pending = {
+      id,
+      kind: "component",
+      name,
+      label,
+      owner,
+      module: this.#moduleDirOf(source.fileName),
+      detail: route ? ["page"] : [],
+      at: { file: relative, line: position.line + 1, column: position.character + 1 }
+    };
+    return context;
+  }
+}
+
+// pkgs/@akanjs/language/ast.ts
+var createAst = (ts) => {
+  const sourceFileFor = (fileName, content, scriptKind = ts.ScriptKind.TS) => ts.createSourceFile(fileName, content, ts.ScriptTarget.Latest, true, scriptKind);
+  const nodeName = (node) => {
+    if (!node)
+      return null;
+    if (ts.isIdentifier(node) || ts.isStringLiteral(node) || ts.isNumericLiteral(node))
+      return node.text;
+    return null;
+  };
+  const propertyName = (node) => ts.isPropertyAssignment(node) || ts.isShorthandPropertyAssignment(node) || ts.isMethodDeclaration(node) ? nodeName(node.name) : null;
+  const expressionName = (expression) => {
+    if (ts.isIdentifier(expression))
+      return expression.text;
+    if (ts.isPropertyAccessExpression(expression))
+      return expression.name.text;
+    if (ts.isCallExpression(expression))
+      return expressionName(expression.expression);
+    if (ts.isAsExpression(expression))
+      return expressionName(expression.expression);
+    return null;
+  };
+  const callExpressionName = (node) => ts.isPropertyAccessExpression(node.expression) ? node.expression.name.text : expressionName(node.expression);
+  const firstObjectReturnedByArrow = (node) => {
+    if (!ts.isArrowFunction(node) && !ts.isFunctionExpression(node))
+      return null;
+    if (ts.isObjectLiteralExpression(node.body))
+      return node.body;
+    if (ts.isParenthesizedExpression(node.body) && ts.isObjectLiteralExpression(node.body.expression)) {
+      return node.body.expression;
+    }
+    if (!ts.isBlock(node.body))
+      return null;
+    for (const statement of node.body.statements) {
+      if (ts.isReturnStatement(statement) && statement.expression && ts.isObjectLiteralExpression(statement.expression)) {
+        return statement.expression;
+      }
+    }
+    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/common/capitalize.ts
+var capitalize2 = (str) => str.charAt(0).toUpperCase() + str.slice(1);
+var lowerlize = (str) => str.charAt(0).toLowerCase() + str.slice(1);
+
+// pkgs/akanjs/common/akanNames.ts
+var sliceNames = (refName, suffix = "") => {
+  const [Model, Suffix] = [capitalize2(refName), capitalize2(suffix)];
+  const live = `${refName}Live${Suffix}`;
+  return {
+    slice: `${refName}${Suffix}`,
+    state: {
+      defaultModel: `default${Model}${Suffix}`,
+      modelInitList: `${refName}InitList${Suffix}`,
+      modelInsight: `${refName}Insight${Suffix}`,
+      modelList: `${refName}List${Suffix}`,
+      modelListLoading: `${refName}ListLoading${Suffix}`,
+      modelInitAt: `${refName}InitAt${Suffix}`,
+      modelStaleAt: `${refName}StaleAt${Suffix}`,
+      lastPageOfModel: `lastPageOf${Model}${Suffix}`,
+      pageOfModel: `pageOf${Model}${Suffix}`,
+      limitOfModel: `limitOf${Model}${Suffix}`,
+      hasMoreOfModel: `hasMoreOf${Model}${Suffix}`,
+      isCumulativeOfModel: `isCumulativeOf${Model}${Suffix}`,
+      hasInsightOfModel: `hasInsightOf${Model}${Suffix}`,
+      queryArgsOfModel: `queryArgsOf${Model}${Suffix}`,
+      sortOfModel: `sortOf${Model}${Suffix}`,
+      modelSelection: `${refName}Selection${Suffix}`
+    },
+    action: {
+      initModel: `init${Model}${Suffix}`,
+      refreshModel: `refresh${Model}${Suffix}`,
+      selectModel: `select${Model}${Suffix}`,
+      setPageOfModel: `setPageOf${Model}${Suffix}`,
+      loadMoreOfModel: `loadMoreOf${Model}${Suffix}`,
+      setLimitOfModel: `setLimitOf${Model}${Suffix}`,
+      setQueryArgsOfModel: `setQueryArgsOf${Model}${Suffix}`,
+      setSortOfModel: `setSortOf${Model}${Suffix}`,
+      applyLiveModel: `applyLive${Model}${Suffix}`,
+      watchLiveModel: `watchLive${Model}${Suffix}`
+    },
+    endpoint: {
+      list: `${refName}List${Suffix}`,
+      insight: `${refName}Insight${Suffix}`,
+      live,
+      subscribeLive: endpointNames(live).subscribe,
+      init: `init${Model}${Suffix}`,
+      getInit: `get${Model}Init${Suffix}`,
+      initResult: `${refName}Init${Suffix}`
+    }
+  };
+};
+var queryNames = (queryKey) => {
+  const Key = capitalize2(queryKey);
+  return {
+    list: `list${Key}`,
+    listIds: `listIds${Key}`,
+    find: `find${Key}`,
+    findId: `findId${Key}`,
+    pick: `pick${Key}`,
+    pickId: `pickId${Key}`,
+    exists: `exists${Key}`,
+    count: `count${Key}`,
+    insight: `insight${Key}`,
+    query: `query${Key}`,
+    remove: `remove${Key}`,
+    removeOne: `removeOne${Key}`,
+    purge: `purge${Key}`,
+    update: `update${Key}`,
+    updateOne: `updateOne${Key}`
+  };
+};
+var databaseStateNames = (refName) => {
+  const className = capitalize2(refName);
+  return {
+    model: refName,
+    modelLoading: `${refName}Loading`,
+    modelForm: `${refName}Form`,
+    modelFormLoading: `${refName}FormLoading`,
+    modelFormUploading: `${refName}FormUploading`,
+    modelSubmit: `${refName}Submit`,
+    modelViewAt: `${refName}ViewAt`,
+    modelModal: `${refName}Modal`,
+    modelDraft: `${refName}FormDraft`,
+    modelOperation: `${refName}Operation`,
+    defaultModel: `default${className}`
+  };
+};
+var modelNames = (refName) => {
+  const Model = capitalize2(refName);
+  return {
+    ...databaseStateNames(refName),
+    getModel: `get${Model}`,
+    loadModel: `load${Model}`,
+    loadModelMany: `load${Model}Many`,
+    createModel: `create${Model}`,
+    createModelMany: `create${Model}Many`,
+    updateModel: `update${Model}`,
+    removeModel: `remove${Model}`,
+    modelModel: `${refName}Model`,
+    modelLoader: `${refName}Loader`,
+    modelCache: `${refName}Cache`,
+    modelId: `${refName}Id`,
+    lightModel: `light${Model}`,
+    viewModel: `view${Model}`,
+    getModelView: `get${Model}View`,
+    modelView: `${refName}View`,
+    editModel: `edit${Model}`,
+    getModelEdit: `get${Model}Edit`,
+    modelEdit: `${refName}Edit`,
+    modelObj: `${refName}Obj`,
+    modelObjList: `${refName}ObjList`,
+    modelObjInsight: `${refName}ObjInsight`,
+    addModelFiles: `add${Model}Files`,
+    mergeModel: `merge${Model}`,
+    createModelInForm: `create${Model}InForm`,
+    updateModelInForm: `update${Model}InForm`,
+    checkModelSubmitable: `check${Model}Submitable`,
+    submitModel: `submit${Model}`,
+    newModel: `new${Model}`,
+    setModel: `set${Model}`,
+    resetModel: `reset${Model}`,
+    invalidateModel: `invalidate${Model}`,
+    loadModelFormDraft: `load${Model}FormDraft`,
+    restoreModelFormDraft: `restore${Model}FormDraft`,
+    discardModelFormDraft: `discard${Model}FormDraft`,
+    writeOnModel: `writeOn${Model}`,
+    setViewOfModel: `setViewOf${Model}`,
+    exportCsvOfModel: `exportCsvOf${Model}`,
+    exportJsonOfModel: `exportJsonOf${Model}`
+  };
+};
+var moduleNames = (refName) => {
+  const Model = capitalize2(refName);
+  return {
+    service: `${refName}Service`,
+    ServiceClass: `${Model}Service`,
+    SliceClass: `${Model}Slice`,
+    ModelClass: `${Model}Model`,
+    FilterClass: `${Model}Filter`,
+    SignalClass: `${Model}Signal`,
+    InternalClass: `${Model}Internal`,
+    EndpointClass: `${Model}Endpoint`
+  };
+};
+var formSetterNames = (className, key) => {
+  const classKeyName = capitalize2(key);
+  return {
+    field: lowerlize(key),
+    Field: classKeyName,
+    setFieldOnModel: `set${classKeyName}On${className}`,
+    addFieldOnModel: `add${classKeyName}On${className}`,
+    subFieldOnModel: `sub${classKeyName}On${className}`,
+    addOrSubFieldOnModel: `addOrSub${classKeyName}On${className}`,
+    moveFieldOnModel: `move${classKeyName}On${className}`,
+    uploadFieldOnModel: `upload${classKeyName}On${className}`,
+    postSetField: `_postSet${classKeyName}`
+  };
+};
+var stateSetterName = (key) => `set${capitalize2(key)}`;
+var endpointNames = (key) => {
+  const Key = capitalize2(key);
+  return { subscribe: `subscribe${Key}`, listen: `listen${Key}` };
+};
+
+// pkgs/@akanjs/language/nameTable.ts
+var capitalize3 = (text) => text.charAt(0).toUpperCase() + text.slice(1);
+
+class NameTable {
+  #byName = new Map;
+  #byFile = new Map;
+  constructor(files) {
+    const all = [...files];
+    const constantsByOwner = new Map;
+    for (const facts of all) {
+      const constants = constantsByOwner.get(facts.owner) ?? [];
+      constants.push(...facts.constants);
+      constantsByOwner.set(facts.owner, constants);
+    }
+    const libConstants = [...constantsByOwner].filter(([owner]) => owner?.startsWith("libs/"));
+    const scope = (owner) => ({
+      own: constantsByOwner.get(owner) ?? [],
+      libs: libConstants.filter(([key]) => key !== owner).flatMap(([, constants]) => constants)
+    });
+    const scopes = new Map;
+    for (const group of NameTable.#groupsOf(all)) {
+      const constants = scopes.get(group.owner) ?? scope(group.owner);
+      scopes.set(group.owner, constants);
+      this.#addGroup(group, constants);
+    }
+  }
+  lookup(name) {
+    return this.#byName.get(name) ?? [];
+  }
+  entriesTargeting(fileName) {
+    return this.#byFile.get(fileName) ?? [];
+  }
+  static #groupsOf(files) {
+    const groups = new Map;
+    const groupOf = (owner, refName) => {
+      const key = `${owner ?? ""}:${refName}`;
+      const group = groups.get(key) ?? { owner, refName, constants: [], slices: [], facts: [] };
+      groups.set(key, group);
+      return group;
+    };
+    for (const facts of files) {
+      const refs = new Set;
+      for (const item of [...facts.services, ...facts.slices, ...facts.endpoints, ...facts.stores, ...facts.models])
+        if (item.model)
+          refs.add(item.model);
+      for (const filter of facts.filters)
+        if (filter.name.endsWith("Filter"))
+          refs.add(NameTable.#lowerFirst(filter.name.slice(0, -6)));
+      for (const constant of facts.constants)
+        refs.add(NameTable.#lowerFirst(constant.name));
+      for (const refName of refs)
+        groupOf(facts.owner, refName).facts.push(facts);
+    }
+    for (const group of groups.values()) {
+      group.constants = group.facts.flatMap((facts) => facts.constants);
+      group.slices = group.facts.flatMap((facts) => facts.slices.filter((slice) => slice.model === group.refName));
+    }
+    return [...groups.values()].filter((group) => group.facts.some((facts) => facts.services.some((item) => item.model === group.refName) || facts.slices.some((item) => item.model === group.refName) || facts.stores.some((item) => item.model === group.refName) || facts.models.some((item) => item.model === group.refName)));
+  }
+  static #lowerFirst(text) {
+    return text.charAt(0).toLowerCase() + text.slice(1);
+  }
+  #add(entry) {
+    if (entry.name === entry.sourceKey)
+      return;
+    const sameName = this.#byName.get(entry.name) ?? [];
+    if (sameName.some((other) => other.gate === entry.gate && other.span.fileName === entry.span.fileName && other.span.start === entry.span.start))
+      return;
+    sameName.push(entry);
+    this.#byName.set(entry.name, sameName);
+    const sameFile = this.#byFile.get(entry.span.fileName) ?? [];
+    sameFile.push(entry);
+    this.#byFile.set(entry.span.fileName, sameFile);
+  }
+  #addGroup(group, constants) {
+    const { owner, refName } = group;
+    const Model = capitalize3(refName);
+    const base = { owner, refName };
+    const modelClass = group.constants.find((constant) => constant.name === Model);
+    const facts = group.facts;
+    const names = moduleNames(refName);
+    const serviceClass = facts.flatMap((file) => file.services).find((item) => item.model === refName);
+    const sliceClass = group.slices[0];
+    const modelDoc = facts.flatMap((file) => file.models).find((item) => item.model === refName);
+    const filterClass = facts.flatMap((file) => file.filters).find((item) => item.name === names.FilterClass);
+    if (serviceClass) {
+      const target = { ...base, family: "module", sourceKey: serviceClass.name, span: serviceClass.span };
+      this.#add({ ...target, name: names.service, role: "service", gate: null, label: serviceClass.name, detail: [] });
+      this.#add({ ...target, name: refName, role: "srv", gate: "srv", label: serviceClass.name, detail: [] });
+    }
+    if (sliceClass)
+      this.#add({
+        ...base,
+        family: "module",
+        sourceKey: sliceClass.name,
+        span: sliceClass.span,
+        name: refName,
+        role: "sig",
+        gate: "sig",
+        label: sliceClass.name,
+        detail: sliceClass.guards.length ? [`guards: ${sliceClass.guards.join(", ")}`] : []
+      });
+    if (modelDoc)
+      this.#add({
+        ...base,
+        family: "module",
+        sourceKey: modelDoc.name,
+        span: modelDoc.span,
+        name: refName,
+        role: "db",
+        gate: "db",
+        label: modelDoc.name,
+        detail: []
+      });
+    const modelRoles = modelNames(refName);
+    const modelNameSet = new Set(Object.values(modelRoles));
+    if (modelClass) {
+      const target = { ...base, family: "model", sourceKey: modelClass.name, span: modelClass.span };
+      for (const [role, name] of Object.entries(modelRoles))
+        this.#add({
+          ...target,
+          name,
+          role,
+          gate: role === "model" ? "state" : null,
+          label: `model ${Model}`,
+          detail: []
+        });
+      for (const [role, name] of Object.entries(databaseStateNames(refName)))
+        this.#add({
+          ...target,
+          name: stateSetterName(name),
+          role: `set:${role}`,
+          gate: null,
+          label: `model ${Model}`,
+          detail: []
+        });
+      for (const field of NameTable.#fieldsOf(modelClass, constants)) {
+        const setters = formSetterNames(Model, field.name);
+        for (const role of [
+          "setFieldOnModel",
+          "addFieldOnModel",
+          "subFieldOnModel",
+          "addOrSubFieldOnModel",
+          "uploadFieldOnModel"
+        ])
+          this.#add({
+            ...base,
+            family: "formSetter",
+            sourceKey: field.name,
+            span: field.span,
+            name: setters[role],
+            role,
+            gate: null,
+            label: `field ${field.declaredIn}.${field.name}`,
+            detail: []
+          });
+      }
+    }
+    for (const slice of group.slices) {
+      const defaultTarget = {
+        ...base,
+        family: "slice",
+        sourceKey: slice.name,
+        span: slice.span,
+        label: `slice ${refName} (default)`,
+        detail: slice.guards.length ? [`guards: ${slice.guards.join(", ")}`] : []
+      };
+      this.#addSliceNames(defaultTarget, refName, "", modelNameSet);
+      for (const key of slice.keys)
+        this.#addSliceNames({
+          ...base,
+          family: "slice",
+          sourceKey: key.name,
+          span: key.span,
+          label: `slice ${key.name}`,
+          detail: [...key.guards.length ? [`guards: ${key.guards.join(", ")}`] : [], ...key.live ? ["live"] : []]
+        }, refName, key.name, modelNameSet, slice.name);
+    }
+    if (filterClass) {
+      const defaults = { ...base, family: "query", detail: [] };
+      for (const [role, name] of Object.entries(queryNames("any")))
+        this.#add({
+          ...defaults,
+          sourceKey: filterClass.name,
+          span: filterClass.span,
+          name,
+          role,
+          gate: null,
+          label: `query any (default) of ${filterClass.name}`
+        });
+      for (const query of filterClass.queries)
+        for (const [role, name] of Object.entries(queryNames(query.name)))
+          this.#add({
+            ...defaults,
+            sourceKey: query.name,
+            span: query.span,
+            name,
+            role,
+            gate: null,
+            label: `query ${query.name}`,
+            renamed: (key) => queryNames(key)[role],
+            dictionary: { section: "query", className: filterClass.name }
+          });
+    }
+    for (const store of facts.flatMap((file) => file.stores).filter((item) => item.model === refName))
+      for (const key of store.stateKeys)
+        this.#add({
+          ...base,
+          family: "storeState",
+          sourceKey: key.name,
+          span: key.span,
+          name: stateSetterName(key.name),
+          role: "set",
+          gate: null,
+          label: `store state ${key.name}`,
+          detail: []
+        });
+    for (const endpoint of facts.flatMap((file) => file.endpoints).filter((item) => item.model === refName))
+      for (const key of endpoint.keys) {
+        const derived = endpointNames(key.name);
+        const name = key.verb === "pubsub" ? derived.subscribe : key.verb === "message" ? derived.listen : null;
+        if (!name)
+          continue;
+        this.#add({
+          ...base,
+          family: "endpoint",
+          sourceKey: key.name,
+          span: key.span,
+          name,
+          role: key.verb === "pubsub" ? "subscribe" : "listen",
+          gate: null,
+          label: `${key.verb} ${key.name}`,
+          detail: key.guards.length ? [`guards: ${key.guards.join(", ")}`] : []
+        });
+      }
+  }
+  static #sliceRoles(refName, suffix) {
+    const names = sliceNames(refName, suffix);
+    return new Map([
+      ["slice", names.slice],
+      ...Object.entries(names.state),
+      ...Object.entries(names.action),
+      ...Object.entries(names.endpoint),
+      ...Object.entries(names.state).map(([role, name]) => [`set:${role}`, stateSetterName(name)])
+    ]);
+  }
+  #addSliceNames(target, refName, suffix, skip, className) {
+    for (const [role, name] of NameTable.#sliceRoles(refName, suffix)) {
+      if (!suffix && role !== "slice" && skip.has(name))
+        continue;
+      this.#add({
+        ...target,
+        name,
+        role,
+        gate: role === "slice" ? "slice" : null,
+        ...suffix && className ? {
+          renamed: (key) => NameTable.#sliceRoles(refName, key).get(role) ?? name,
+          dictionary: { section: "slice", className }
+        } : {}
+      });
+    }
+  }
+  static #fieldsOf(modelClass, { own, libs }) {
+    const classNamed = (name, near) => own.find((constant) => constant.name === name && constant.span.fileName === near.span.fileName) ?? own.find((constant) => constant.name === name) ?? libs.find((constant) => constant.name === name);
+    const fields = new Map;
+    const seen = new Set;
+    const visit = (constant) => {
+      if (seen.has(constant))
+        return;
+      seen.add(constant);
+      for (const field of constant.fields)
+        if (!fields.has(field.name))
+          fields.set(field.name, { ...field, declaredIn: constant.name });
+      for (const parent of constant.parents) {
+        const parentClass = classNamed(parent, constant);
+        if (parentClass)
+          visit(parentClass);
+      }
+    };
+    visit(modelClass);
+    return [...fields.values()];
+  }
+}
+
+// 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;
+var stateReceivers = new Set(["use", "sel", "get", "do"]);
+var lensFamilies = new Set(["slice", "query", "formSetter", "storeState", "endpoint"]);
+var modellessFamilies = new Set(["query", "storeState", "endpoint"]);
+var gateWords = { srv: "srv", sig: "sig", db: "db", slice: "slice" };
+var parseCacheSize = 64;
+var pathOf = (fileName) => fileName.replace(/\\/g, "/");
+var escapeRegExp = (text) => text.replace(regExpSpecials, (special) => `\\${special}`);
+var receiverGap = String.raw`(?:\s|\)|\/\*[\s\S]*?\*\/)*`;
+
+class AkanIndex {
+  #ts;
+  #root;
+  #ast;
+  #reader;
+  #facts = new Map;
+  #fileWords = new Map;
+  #parsed = new Map;
+  #table = null;
+  constructor({ ts, root }) {
+    this.#ts = ts;
+    this.#root = pathOf(root).replace(/\/$/, "");
+    this.#ast = createAst(ts);
+    this.#reader = createFactReader(ts, this.#ast);
+  }
+  static isSourcePath(fileName) {
+    return sourcePattern.test(fileName);
+  }
+  get fileCount() {
+    return this.#fileWords.size;
+  }
+  setFile(givenName, text) {
+    const fileName = pathOf(givenName);
+    const words = `
+${[...new Set(text.match(wordPattern))].join(`
+`)}
+`;
+    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)));
+    if (isSource)
+      this.#table = null;
+  }
+  removeFile(givenName) {
+    const fileName = pathOf(givenName);
+    this.#fileWords.delete(fileName);
+    this.#parsed.delete(fileName);
+    if (this.#facts.delete(fileName) && AkanIndex.isSourcePath(fileName))
+      this.#table = null;
+  }
+  definitionAt(givenName, text, offset) {
+    const fileName = pathOf(givenName);
+    const site = this.#useAt(this.#parse(fileName, text), offset);
+    return site ? this.#resolve(fileName, site) : [];
+  }
+  hoverAt(givenName, text, offset) {
+    const fileName = pathOf(givenName);
+    const site = this.#useAt(this.#parse(fileName, text), offset);
+    if (!site)
+      return null;
+    const targets = this.#resolve(fileName, site);
+    return targets.length ? { name: site.identifier.text, targets } : null;
+  }
+  sourceKeysOf(givenName) {
+    const keys = new Map;
+    for (const entry of this.#nameTable().entriesTargeting(pathOf(givenName))) {
+      if (!lensFamilies.has(entry.family) || keys.has(entry.span.start))
+        continue;
+      keys.set(entry.span.start, AkanIndex.#sourceKeyOf(entry));
+    }
+    return [...keys.values()].sort((a, b) => a.span.start - b.span.start);
+  }
+  sourceKeyAt(givenName, offset) {
+    const entries = this.#sourceEntriesAt(pathOf(givenName), offset);
+    const entry = entries.find((candidate) => lensFamilies.has(candidate.family)) ?? entries.at(0);
+    return entry ? AkanIndex.#sourceKeyOf(entry) : null;
+  }
+  referencesAt(givenName, offset, readText) {
+    return this.#usesOf(this.#sourceEntriesAt(pathOf(givenName), offset), readText).map((use) => use.span);
+  }
+  graph(readText, { digests = false } = {}) {
+    return new GraphBuilder({
+      digests,
+      ts: this.#ts,
+      facts: [...this.#facts].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([, facts]) => facts),
+      files: [...this.#fileWords].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0),
+      readText,
+      parse: (fileName, text) => this.#parse(fileName, text),
+      resolve: (fileName, identifier) => {
+        if (!this.#nameTable().lookup(identifier.text).length)
+          return [];
+        const site = this.#siteOf(identifier);
+        return site ? this.#resolve(fileName, site) : [];
+      },
+      relative: (fileName) => this.#relative(fileName),
+      ownerOf: (fileName) => this.#ownerOf(fileName),
+      reader: this.#reader
+    }).build();
+  }
+  renameTargetAt(givenName, offset) {
+    const source = this.#sourceEntriesAt(pathOf(givenName), offset).find((entry) => entry.renamed);
+    return source ? { family: source.family, sourceKey: source.sourceKey, span: source.span } : null;
+  }
+  renameAt(givenName, offset, newKey, readText) {
+    const sources = this.#sourceEntriesAt(pathOf(givenName), offset).filter((entry) => entry.renamed);
+    if (!sources.length || !identifierPattern.test(newKey))
+      return null;
+    return [
+      { span: sources[0].span, newText: newKey },
+      ...this.#usesOf(sources, readText).map(({ span, entry, shorthand }) => {
+        const renamed = entry.renamed?.(newKey) ?? entry.name;
+        return { span, newText: shorthand ? `${renamed}: ${entry.name}` : renamed };
+      }),
+      ...this.#dictionaryKeysOf(sources[0], readText).map(({ span, quote }) => ({
+        span,
+        newText: `${quote}${newKey}${quote}`
+      }))
+    ];
+  }
+  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 };
+  }
+  #usesOf(sources, readText) {
+    if (!sources.length)
+      return [];
+    const ts = this.#ts;
+    const isSource = (target) => sources.some((source) => source.span.fileName === target.span.fileName && source.span.start === target.span.start);
+    const refNames = new Set(sources.map((source) => source.refName));
+    const byName = new Map(sources.map((source) => [source.name, source]));
+    const naming = new RegExp(`\\n(?:${[...byName.keys()].map(escapeRegExp).join("|")})\\n`);
+    const gateWordsOf = sources.map((source) => source.gate ? gateWords[source.gate] : undefined);
+    const receiverPatterns = sources.map((source, at) => {
+      const gateWord = gateWordsOf[at];
+      return gateWord ? new RegExp(String.raw`(?<![\w$])${gateWord}${receiverGap}[?!]?\.${receiverGap}${escapeRegExp(source.name)}(?![\w$])`) : null;
+    });
+    const named = (words, at) => words.includes(`
+${sources[at].name}
+`) && (!gateWordsOf[at] || words.includes(`
+${gateWordsOf[at]}
+`));
+    const candidates = [...this.#fileWords].filter(([, words]) => naming.test(words) && sources.some((_, at) => named(words, at)));
+    const found = [];
+    for (const [file, words] of candidates.sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)) {
+      const text = readText(file);
+      if (text === undefined)
+        continue;
+      if (!sources.some((_, at) => named(words, at) && (receiverPatterns[at]?.test(text) ?? true)))
+        continue;
+      const source = this.#parse(file, text);
+      const visit = (node) => {
+        const entry = ts.isIdentifier(node) ? byName.get(node.text) : undefined;
+        const site = entry && ts.isIdentifier(node) ? this.#siteOf(node) : null;
+        const targets = site ? this.#resolve(file, site) : [];
+        if (entry && site && targets.some(isSource) && targets.every((target) => refNames.has(target.refName))) {
+          const parent = site.identifier.parent;
+          const shorthand = ts.isBindingElement(parent) && !parent.propertyName;
+          found.push({ span: this.#reader.spanOf(source, site.identifier), entry, shorthand });
+        }
+        ts.forEachChild(node, visit);
+      };
+      visit(source);
+    }
+    return found;
+  }
+  #dictionaryKeysOf(source, readText) {
+    const { dictionary } = source;
+    if (!dictionary)
+      return [];
+    const ts = this.#ts;
+    const keys = [];
+    const moduleDir = source.span.fileName.slice(0, source.span.fileName.lastIndexOf("/"));
+    for (const [file, words] of this.#fileWords) {
+      if (!dictionaryPattern.test(file) || this.#ownerOf(file) !== source.owner)
+        continue;
+      const sameModule = file.slice(0, file.lastIndexOf("/")) === moduleDir;
+      if (!words.includes(`
+${dictionary.section}
+`))
+        continue;
+      if (!sameModule && !words.includes(`
+${dictionary.className}
+`))
+        continue;
+      const text = readText(file);
+      if (text === undefined)
+        continue;
+      const parsed = this.#parse(file, text);
+      const visit = (node) => {
+        const typeArgument = ts.isCallExpression(node) ? node.typeArguments?.[0] : undefined;
+        const builder = ts.isCallExpression(node) ? node.arguments.at(-1) : undefined;
+        const typed = !!typeArgument && ts.isTypeReferenceNode(typeArgument) && ts.isIdentifier(typeArgument.typeName) && typeArgument.typeName.text === dictionary.className;
+        const untyped = !typeArgument && sameModule;
+        const object = ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && node.expression.name.text === dictionary.section && (typed || untyped) && builder ? this.#ast.firstObjectReturnedByArrow(builder) : null;
+        for (const property of object?.properties ?? [])
+          if (ts.isPropertyAssignment(property) && this.#ast.nodeName(property.name) === source.sourceKey)
+            keys.push({
+              span: this.#reader.spanOf(parsed, property.name),
+              quote: ts.isStringLiteral(property.name) ? parsed.text.charAt(property.name.getStart(parsed)) : ""
+            });
+        ts.forEachChild(node, visit);
+      };
+      visit(parsed);
+    }
+    return keys;
+  }
+  #sourceEntriesAt(fileName, offset) {
+    return this.#nameTable().entriesTargeting(fileName).filter((entry) => entry.span.start <= offset && offset <= entry.span.end);
+  }
+  #nameTable() {
+    this.#table ??= new NameTable([...this.#facts.values()].filter(({ fileName }) => AkanIndex.isSourcePath(fileName)));
+    return this.#table;
+  }
+  #relative(fileName) {
+    return fileName.startsWith(`${this.#root}/`) ? fileName.slice(this.#root.length + 1) : fileName;
+  }
+  #ownerOf(fileName) {
+    return ownerOf(this.#relative(fileName));
+  }
+  #parseUncached(fileName, text) {
+    const kind = fileName.endsWith(".tsx") ? this.#ts.ScriptKind.TSX : this.#ts.ScriptKind.TS;
+    return this.#ast.sourceFileFor(fileName, text, kind);
+  }
+  #parse(fileName, text) {
+    const cached = this.#parsed.get(fileName);
+    if (cached?.text === text)
+      return cached.source;
+    const source = this.#parseUncached(fileName, text);
+    this.#parsed.delete(fileName);
+    this.#parsed.set(fileName, { text, source });
+    if (this.#parsed.size > parseCacheSize) {
+      const oldest = this.#parsed.keys().next().value;
+      if (oldest !== undefined)
+        this.#parsed.delete(oldest);
+    }
+    return source;
+  }
+  #useAt(source, offset) {
+    const ts = this.#ts;
+    let found = null;
+    const visit = (node) => {
+      if (offset < node.getStart(source) || offset > node.getEnd())
+        return;
+      if (ts.isIdentifier(node))
+        found = node;
+      ts.forEachChild(node, visit);
+    };
+    visit(source);
+    return found ? this.#siteOf(found) : null;
+  }
+  #siteOf(identifier) {
+    const ts = this.#ts;
+    const parent = identifier.parent;
+    let chain;
+    if (ts.isPropertyAccessExpression(parent) && parent.name === identifier)
+      chain = this.#chainOf(parent.expression);
+    else if (ts.isBindingElement(parent) && !parent.dotDotDotToken && ts.isObjectBindingPattern(parent.parent) && (parent.propertyName === identifier || !parent.propertyName && parent.name === identifier))
+      chain = null;
+    else
+      return null;
+    const { model, inStore } = this.#classContextOf(identifier);
+    return { identifier, chain, classModel: model, inStore };
+  }
+  #chainOf(expression) {
+    const ts = this.#ts;
+    if (ts.isNonNullExpression(expression) || ts.isParenthesizedExpression(expression))
+      return this.#chainOf(expression.expression);
+    if (ts.isIdentifier(expression))
+      return [expression.text];
+    if (expression.kind === ts.SyntaxKind.ThisKeyword)
+      return ["this"];
+    if (ts.isPropertyAccessExpression(expression))
+      return [...this.#chainOf(expression.expression), expression.name.text];
+    return ["?"];
+  }
+  #classContextOf(node) {
+    const ts = this.#ts;
+    let current = node.parent;
+    while (current && !ts.isClassDeclaration(current) && !ts.isClassExpression(current))
+      current = current.parent;
+    if (!current)
+      return { model: null, inStore: false };
+    const className = current.name?.text;
+    const heritage = current.heritageClauses?.flatMap((clause) => [...clause.types]) ?? [];
+    for (const { expression } of heritage) {
+      if (!ts.isCallExpression(expression))
+        continue;
+      const callee = this.#ast.expressionName(expression.expression);
+      if (callee === "into" && className?.endsWith("Model"))
+        return { model: className.charAt(0).toLowerCase() + className.slice(1, -5), inStore: false };
+      const holder = callee === "serve" ? "db" : callee === "store" ? "sig" : callee === "slice" || callee === "endpoint" || callee === "internal" ? "srv" : null;
+      if (!holder)
+        continue;
+      return { model: this.#reader.moduleRefOf(expression.arguments[0], holder), inStore: callee === "store" };
+    }
+    return { model: null, inStore: false };
+  }
+  #modelHintOf(site) {
+    const { chain } = site;
+    if (!chain)
+      return null;
+    if (chain.length === 1 && chain[0] === "this")
+      return site.classModel;
+    const holder = chain.at(-1)?.replace(/^#/, "");
+    const suffix = holder?.match(/.(Service|Model)$/)?.[1];
+    if (holder && suffix)
+      return holder.slice(0, -suffix.length);
+    if (chain.length === 2 && (chain[0] === "db" || chain[0] === "srv"))
+      return chain[1];
+    return null;
+  }
+  #passesGate(entry, site) {
+    const { chain } = site;
+    const last = chain?.at(-1);
+    switch (entry.gate) {
+      case "srv":
+      case "sig":
+      case "db":
+        return chain?.length === 1 && last === entry.gate;
+      case "slice":
+        return last === "slice";
+      case "state":
+        return !!last && stateReceivers.has(last) || site.inStore && chain?.length === 1 && last === "this";
+      default:
+        return true;
+    }
+  }
+  #resolve(fileName, site) {
+    const owner = this.#ownerOf(fileName);
+    const visible = this.#nameTable().lookup(site.identifier.text).filter((entry) => this.#passesGate(entry, site) && (!owner || !entry.owner || entry.owner === owner || entry.owner.startsWith("libs/")));
+    const hint = this.#modelHintOf(site);
+    const hinted = hint ? visible.filter((entry) => entry.refName === hint) : [];
+    const chosen = hinted.length ? hinted : hint ? visible.filter((entry) => !modellessFamilies.has(entry.family)) : visible;
+    return chosen.map(({ family, refName, owner: entryOwner, sourceKey, label, detail, span }) => ({
+      family,
+      refName,
+      owner: entryOwner,
+      sourceKey,
+      label,
+      detail,
+      span
+    })).sort((a, b) => Number(b.owner === owner) - Number(a.owner === owner));
+  }
+}
+
+// pkgs/@akanjs/language/lspConnection.ts
+var lspErrors = {
+  parseError: -32700,
+  invalidRequest: -32600,
+  methodNotFound: -32601,
+  internalError: -32603,
+  serverNotInitialized: -32002
+};
+var headerEnd = Buffer.from(`\r
+\r
+`);
+var contentLength = /^content-length:\s*(\d+)\s*$/im;
+
+class LspConnection {
+  #output;
+  #onMessage;
+  #buffer = Buffer.alloc(0);
+  #nextId = 0;
+  constructor(input, output, onMessage) {
+    this.#output = output;
+    this.#onMessage = onMessage;
+    input.on("data", (chunk) => this.#read(typeof chunk === "string" ? Buffer.from(chunk) : chunk));
+  }
+  #read(chunk) {
+    this.#buffer = Buffer.concat([this.#buffer, chunk]);
+    for (;; ) {
+      const end = this.#buffer.indexOf(headerEnd);
+      if (end < 0)
+        return;
+      const length = this.#buffer.subarray(0, end).toString("ascii").match(contentLength)?.[1];
+      const start = end + headerEnd.length;
+      if (length === undefined) {
+        this.#buffer = this.#buffer.subarray(start);
+        continue;
+      }
+      if (this.#buffer.length < start + Number(length))
+        return;
+      const body = this.#buffer.subarray(start, start + Number(length)).toString("utf8");
+      this.#buffer = this.#buffer.subarray(start + Number(length));
+      this.#dispatch(body);
+    }
+  }
+  #dispatch(body) {
+    let message;
+    try {
+      message = JSON.parse(body);
+    } catch {
+      this.fail(null, lspErrors.parseError, "The message is not JSON.");
+      return;
+    }
+    if (typeof message === "object" && message !== null && !Array.isArray(message))
+      this.#onMessage(message);
+    else
+      this.fail(null, lspErrors.invalidRequest, "The message is not a JSON-RPC object.");
+  }
+  send(message) {
+    const body = Buffer.from(JSON.stringify(message), "utf8");
+    this.#output.write(Buffer.concat([Buffer.from(`Content-Length: ${body.length}\r
+\r
+`, "ascii"), body]));
+  }
+  respond(id, result) {
+    this.send({ jsonrpc: "2.0", id, result: result ?? null });
+  }
+  fail(id, code, message) {
+    this.send({ jsonrpc: "2.0", id, error: { code, message } });
+  }
+  notify(method, params) {
+    this.send({ jsonrpc: "2.0", method, params });
+  }
+  request(method, params) {
+    this.send({ jsonrpc: "2.0", id: `akan-${++this.#nextId}`, method, params });
+  }
+}
+
+// pkgs/@akanjs/language/akanLanguageServer.ts
+var systemKinds = ["apps", "libs"];
+var isSkippedDir = (name) => name === "node_modules" || name === "dist" || name.startsWith(".");
+var indexedPath = /^(apps|libs)\/(?!(?:.*\/)?(?:node_modules|dist|\.[^/]*)\/).*\.tsx?$/;
+var sourceGlob = "{apps,libs}/**/*.{ts,tsx}";
+var editDelayMs = 150;
+var filesPerYield = 200;
+var infoMessage = 3;
+var unknownMethod = Symbol("unknownMethod");
+var isDirectory = (dir) => {
+  try {
+    return statSync(dir).isDirectory();
+  } catch {
+    return false;
+  }
+};
+var fileOf = (uri) => {
+  try {
+    return fileURLToPath(uri);
+  } catch {
+    return null;
+  }
+};
+var isAkanRoot = (dir) => systemKinds.some((kind) => {
+  try {
+    return readdirSync(path.join(dir, kind)).some((system) => existsSync(path.join(dir, kind, system, "akan.config.ts")));
+  } catch {
+    return false;
+  }
+});
+var workspaceRootOf = (dir) => {
+  const parent = path.dirname(dir);
+  if (isAkanRoot(dir))
+    return dir;
+  return parent === dir ? null : workspaceRootOf(parent);
+};
+var caseOf = (fileName) => process.platform === "win32" ? fileName.toLowerCase() : fileName;
+var sourceFilesOf = (root) => {
+  const found = [];
+  const visited = new Set;
+  const walk = (dir) => {
+    let entries;
+    try {
+      const real = realpathSync(dir);
+      if (visited.has(real))
+        return;
+      visited.add(real);
+      entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      const at = path.join(dir, entry.name);
+      const isDir = entry.isDirectory() || entry.isSymbolicLink() && isDirectory(at);
+      if (isDir && !isSkippedDir(entry.name))
+        walk(at);
+      else if (!isDir && /\.tsx?$/.test(entry.name))
+        found.push(at);
+    }
+  };
+  for (const kind of systemKinds)
+    walk(path.join(root, kind));
+  return found;
+};
+var offsetAt = (text, { line, character }) => {
+  const breaks = [...text.matchAll(/\r\n|\r|\n/g)];
+  if (line > breaks.length)
+    return text.length;
+  const start = line === 0 ? 0 : breaks[line - 1].index + breaks[line - 1][0].length;
+  const end = line < breaks.length ? breaks[line].index : text.length;
+  return Math.min(start + character, end);
+};
+var positionAt = (text, offset) => {
+  const breaks = [...text.slice(0, offset).matchAll(/\r\n|\r|\n/g)];
+  const last = breaks.at(-1);
+  return { line: breaks.length, character: last ? offset - last.index - last[0].length : offset };
+};
+var escapeMarkdown = (text) => text.replace(/[\\`*_{}[\]()#+\-.!|<>]/g, "\\$&");
+var messageOf = (error) => error instanceof Error ? error.message : String(error);
+var yieldToLoop = () => new Promise((resolve) => setImmediate(resolve));
+
+class AkanLanguageServer {
+  #ts;
+  #connection;
+  #exit;
+  #open = new Map;
+  #pendingEdits = new Map;
+  #roots = [];
+  #ready = Promise.resolve();
+  #queue = Promise.resolve();
+  #watchesFiles = false;
+  #watchesRelative = false;
+  #hoversMarkdown = true;
+  #isInitialized = false;
+  #isShutdown = false;
+  constructor({ ts, input, output, exit }) {
+    this.#ts = ts;
+    this.#exit = exit;
+    this.#connection = new LspConnection(input, output, (message) => this.#handle(message));
+    input.on("end", () => this.#stop());
+  }
+  #handle(message) {
+    this.#queue = this.#queue.then(() => this.#process(message)).catch((error) => this.#log(messageOf(error)));
+  }
+  async#process({ id, method, params }) {
+    if (method === undefined)
+      return;
+    if (id !== undefined && id !== null)
+      return await this.#answer(id, method, params);
+    if (this.#isInitialized || method === "exit")
+      this.#notified(method, params);
+  }
+  async#answer(id, method, params) {
+    if (!this.#isInitialized && method !== "initialize")
+      return this.#connection.fail(id, lspErrors.serverNotInitialized, "The server is not initialized yet.");
+    if (this.#isShutdown)
+      return this.#connection.fail(id, lspErrors.invalidRequest, "The server is shutting down.");
+    try {
+      const result = await this.#result(method, params);
+      if (result === unknownMethod)
+        this.#connection.fail(id, lspErrors.methodNotFound, `${method} is not supported.`);
+      else
+        this.#connection.respond(id, result);
+    } catch (error) {
+      this.#connection.fail(id, lspErrors.internalError, messageOf(error));
+    }
+  }
+  async#result(method, params) {
+    switch (method) {
+      case "initialize":
+        return this.#initialize(params);
+      case "shutdown":
+        this.#isShutdown = true;
+        return null;
+      case "textDocument/definition":
+        return await this.#definition(params);
+      case "textDocument/references":
+        return await this.#references(params);
+      case "textDocument/hover":
+        return await this.#hover(params);
+      default:
+        return unknownMethod;
+    }
+  }
+  #notified(method, params) {
+    switch (method) {
+      case "initialized":
+        return this.#watch();
+      case "exit":
+        return this.#stop();
+      case "textDocument/didOpen": {
+        const { textDocument } = params;
+        return this.#opened(textDocument.uri, textDocument.text);
+      }
+      case "textDocument/didChange": {
+        const { textDocument, contentChanges } = params;
+        const text = contentChanges.at(-1)?.text;
+        return text === undefined ? undefined : this.#changed(textDocument.uri, text);
+      }
+      case "textDocument/didClose":
+        return this.#closed(params.textDocument.uri);
+      case "workspace/didChangeWatchedFiles":
+        for (const { uri } of params.changes)
+          this.#changedOnDisk(uri);
+        return;
+      default:
+        return;
+    }
+  }
+  #initialize(params) {
+    this.#isInitialized = true;
+    const watched = params.capabilities?.workspace?.didChangeWatchedFiles;
+    this.#watchesFiles = watched?.dynamicRegistration === true;
+    this.#watchesRelative = watched?.relativePatternSupport === true;
+    this.#hoversMarkdown = params.capabilities?.textDocument?.hover?.contentFormat?.includes("markdown") ?? true;
+    const given = params.workspaceFolders?.length ? params.workspaceFolders.map((folder) => fileOf(folder.uri)) : [params.rootUri ? fileOf(params.rootUri) : params.rootPath ?? null];
+    const roots = new Set(given.flatMap((dir) => dir ? [workspaceRootOf(path.resolve(dir))] : []));
+    this.#roots = [...roots].flatMap((root) => root ? [{ root, index: new AkanIndex({ ts: this.#ts, root }) }] : []).sort((a, b) => b.root.length - a.root.length);
+    this.#ready = yieldToLoop().then(() => this.#fill());
+    return {
+      capabilities: {
+        positionEncoding: "utf-16",
+        textDocumentSync: { openClose: true, change: 1 },
+        definitionProvider: true,
+        referencesProvider: true,
+        hoverProvider: true
+      },
+      serverInfo: { name: "akan-language-server" }
+    };
+  }
+  async#fill() {
+    for (const entry of this.#roots) {
+      const started = Date.now();
+      const failures = [];
+      for (const [at, fileName] of sourceFilesOf(entry.root).entries()) {
+        if (at % filesPerYield === filesPerYield - 1)
+          await yieldToLoop();
+        const text = this.#readText(fileName);
+        try {
+          if (text !== undefined)
+            entry.index.setFile(fileName, text);
+        } catch (error) {
+          failures.push(error);
+        }
+      }
+      const skipped = failures.length ? `; skipped ${failures.length}: ${messageOf(failures[0])}` : "";
+      this.#log(`akan: indexed ${entry.index.fileCount} files in ${Date.now() - started}ms at ${entry.root}${skipped}`);
+    }
+  }
+  #watch() {
+    if (!this.#watchesFiles || !this.#roots.length)
+      return;
+    const watchers = this.#watchesRelative ? this.#roots.map(({ root }) => ({ globPattern: { baseUri: pathToFileURL(root).href, pattern: sourceGlob } })) : [{ globPattern: `**/${sourceGlob}` }];
+    this.#connection.request("client/registerCapability", {
+      registrations: [
+        { id: "akan-source-files", method: "workspace/didChangeWatchedFiles", registerOptions: { watchers } }
+      ]
+    });
+  }
+  #stop() {
+    for (const timer of this.#pendingEdits.values())
+      clearTimeout(timer);
+    this.#pendingEdits.clear();
+    this.#exit(this.#isShutdown ? 0 : 1);
+  }
+  #log(message) {
+    this.#connection.notify("window/logMessage", { type: infoMessage, message });
+  }
+  #readText = (fileName) => {
+    const open = this.#open.get(path.resolve(fileName));
+    if (open !== undefined)
+      return open;
+    try {
+      return readFileSync(fileName, "utf8");
+    } catch {
+      return;
+    }
+  };
+  #rootOf(fileName) {
+    return this.#roots.find(({ root }) => caseOf(fileName).startsWith(caseOf(`${root}${path.sep}`))) ?? null;
+  }
+  #locationsOf(spans) {
+    const texts = new Map;
+    return spans.map(({ fileName, start, end, line, character, endLine, endCharacter }) => {
+      if (!texts.has(fileName))
+        texts.set(fileName, this.#readText(fileName));
+      const text = texts.get(fileName);
+      return {
+        uri: pathToFileURL(fileName).href,
+        range: text === undefined ? { start: { line, character }, end: { line: endLine, character: endCharacter } } : { start: positionAt(text, start), end: positionAt(text, end) }
+      };
+    });
+  }
+  #update(fileName) {
+    const entry = this.#rootOf(fileName);
+    const relative = entry ? path.relative(entry.root, fileName).split(path.sep).join("/") : "";
+    if (!entry || !indexedPath.test(relative))
+      return;
+    const text = this.#readText(fileName);
+    try {
+      if (text === undefined)
+        entry.index.removeFile(fileName);
+      else
+        entry.index.setFile(fileName, text);
+    } catch (error) {
+      this.#log(`akan: ${fileName}: ${messageOf(error)}`);
+    }
+  }
+  #flush() {
+    for (const [fileName, timer] of this.#pendingEdits) {
+      clearTimeout(timer);
+      this.#update(fileName);
+    }
+    this.#pendingEdits.clear();
+  }
+  #opened(uri, text) {
+    const fileName = fileOf(uri);
+    if (!fileName)
+      return;
+    this.#open.set(path.resolve(fileName), text);
+    this.#update(path.resolve(fileName));
+  }
+  #changed(uri, text) {
+    const fileName = fileOf(uri);
+    if (!fileName)
+      return;
+    const key = path.resolve(fileName);
+    this.#open.set(key, text);
+    clearTimeout(this.#pendingEdits.get(key));
+    this.#pendingEdits.set(key, setTimeout(() => {
+      this.#pendingEdits.delete(key);
+      this.#update(key);
+    }, editDelayMs));
+  }
+  #closed(uri) {
+    const fileName = fileOf(uri);
+    if (!fileName)
+      return;
+    const key = path.resolve(fileName);
+    clearTimeout(this.#pendingEdits.get(key));
+    this.#pendingEdits.delete(key);
+    this.#open.delete(key);
+    this.#update(key);
+  }
+  #changedOnDisk(uri) {
+    const fileName = fileOf(uri);
+    if (fileName && !this.#open.has(path.resolve(fileName)))
+      this.#update(path.resolve(fileName));
+  }
+  async#locate({ textDocument, position }) {
+    await this.#ready;
+    this.#flush();
+    const given = fileOf(textDocument.uri);
+    const fileName = given ? path.resolve(given) : null;
+    const entry = fileName ? this.#rootOf(fileName) : null;
+    const text = fileName ? this.#readText(fileName) : undefined;
+    if (!fileName || !entry || text === undefined)
+      return null;
+    return { entry, fileName, text, offset: offsetAt(text, position) };
+  }
+  async#definition(params) {
+    const at = await this.#locate(params);
+    return at && this.#locationsOf(at.entry.index.definitionAt(at.fileName, at.text, at.offset).map(({ span }) => span));
+  }
+  async#references(params) {
+    const at = await this.#locate(params);
+    if (!at)
+      return null;
+    const uses = at.entry.index.referencesAt(at.fileName, at.offset, this.#readText);
+    const key = params.context?.includeDeclaration && uses.length ? at.entry.index.sourceKeyAt(at.fileName, at.offset) : null;
+    return this.#locationsOf(key ? [key.span, ...uses] : uses);
+  }
+  async#hover(params) {
+    const at = await this.#locate(params);
+    const hover = at?.entry.index.hoverAt(at.fileName, at.text, at.offset);
+    if (!at || !hover)
+      return null;
+    const lines = this.#locationsOf(hover.targets.map(({ span }) => span)).map(({ range }) => range.start.line + 1);
+    const lineOf = (target, idx) => {
+      const summary = [target.label, ...target.detail].join(" · ");
+      const where = `${path.relative(at.entry.root, target.span.fileName).split(path.sep).join("/")}:${lines[idx]}`;
+      return this.#hoversMarkdown ? `**akan** · ${escapeMarkdown(summary)} — \`${where}\`` : `akan · ${summary} — ${where}`;
+    };
+    return {
+      contents: {
+        kind: this.#hoversMarkdown ? "markdown" : "plaintext",
+        value: hover.targets.map(lineOf).join(`
+
+`)
+      }
+    };
+  }
+}
+
+// pkgs/@akanjs/language/server.ts
+if (!process.argv.includes("--stdio")) {
+  process.stderr.write("akan-language-server speaks LSP over stdio: run it as `akan-language-server --stdio`.\n");
+  process.exit(2);
+}
+var ts = await import("typescript").then((loaded) => loaded.default ?? loaded, () => null);
+if (!ts) {
+  process.stderr.write("akan-language-server needs the `typescript` package installed next to @akanjs/language.\n");
+  process.exit(1);
+}
+new AkanLanguageServer({ ts, input: process.stdin, output: process.stdout, exit: (code) => process.exit(code) });