@akanjs/language 3.1.2-rc.3 → 3.1.2-rc.4

package/server.js

@@ -0,0 +1,1890 @@
+#!/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/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"]);
+
+class GraphBuilder {
+  #source;
+  #nodes = new Map;
+  #edges = new Map;
+  #contexts = new Map;
+  #members = new Map;
+  constructor(source) {
+    this.#source = source;
+  }
+  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) {
+      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 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);
+        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);
+        }
+      }
+      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);
+        }
+      }
+      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);
+      }
+    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(text, { start, end }) {
+    if (!this.#source.digests || text === undefined)
+      return null;
+    let hash = 2166136261;
+    for (let idx = start;idx < end; idx++) {
+      const code = text.charCodeAt(idx);
+      if (code !== 13)
+        hash = Math.imul(hash ^ code, 16777619);
+    }
+    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) {
+    const [role, name] = guard.includes(" ") ? guard.split(" ") : [null, guard];
+    if (!name || name === "?")
+      return;
+    const id = `guard:${name}`;
+    if (!this.#nodes.has(id))
+      this.#nodes.set(id, { id, kind: "guard", name, label: name, owner: null, module: null, detail: [], at: null });
+    this.#addEdge(node.id, id, "guard", role, node.at);
+  }
+  #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/");
+  }
+  #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 resolved = 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);
+  }
+  #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 id = `component:${relative}#${name}`;
+    const context = {
+      id,
+      kind: "component",
+      owner,
+      module: null,
+      extent: { start: top.getStart(source), end: top.getEnd() }
+    };
+    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/language/moduleFacts.ts
+var moduleCallees = new Set(["via", "from", "into", "serve", "slice", "endpoint", "store", "enumOf"]);
+var argMethods = new Set(["param", "body", "search", "room", "msg"]);
+var ownerOf = (relativePath) => {
+  const [root, name] = relativePath.split("/");
+  return (root === "apps" || root === "libs") && name ? `${root}/${name}` : null;
+};
+var createFactReader = (ts, ast) => {
+  const spanOf = (source, node) => {
+    const start = node.getStart(source);
+    const end = node.getEnd();
+    const head = source.getLineAndCharacterOfPosition(start);
+    const tail = source.getLineAndCharacterOfPosition(end);
+    return {
+      fileName: source.fileName,
+      start,
+      end,
+      line: head.line,
+      character: head.character,
+      endLine: tail.line,
+      endCharacter: tail.character
+    };
+  };
+  const extentOf = (source, node) => ({
+    start: node.getStart(source),
+    end: node.getEnd()
+  });
+  const unwrap = (expression) => {
+    let current = expression;
+    while (ts.isParenthesizedExpression(current) || ts.isAsExpression(current) || ts.isSatisfiesExpression(current))
+      current = current.expression;
+    return current;
+  };
+  const moduleRefOf = (expression, holder) => {
+    let current = expression && unwrap(expression);
+    while (current && ts.isCallExpression(current) && ts.isPropertyAccessExpression(current.expression))
+      current = current.expression.expression;
+    if (current && ts.isStringLiteral(current))
+      return current.text;
+    if (!current || !ts.isPropertyAccessExpression(current))
+      return null;
+    return ts.isIdentifier(current.expression) && current.expression.text === holder ? current.name.text : null;
+  };
+  const returnedObject = (builder) => builder ? ast.firstObjectReturnedByArrow(builder) : null;
+  const builderOf = (call) => [...call.arguments].reverse().find((arg) => ts.isArrowFunction(arg) || ts.isFunctionExpression(arg));
+  const guardsIn = (object) => {
+    const guards = object?.properties.find((property) => ts.isPropertyAssignment(property) && ast.nodeName(property.name) === "guards")?.initializer;
+    if (!guards)
+      return [];
+    if (ts.isArrayLiteralExpression(guards))
+      return guards.elements.map((element) => ast.expressionName(element)).filter((name) => name !== null);
+    if (ts.isObjectLiteralExpression(guards))
+      return guards.properties.filter(ts.isPropertyAssignment).map((property) => `${ast.nodeName(property.name)} ${ast.expressionName(property.initializer) ?? "?"}`);
+    const single = ast.expressionName(guards);
+    return single ? [single] : [];
+  };
+  const optionObjectOf = (call) => call.arguments.find((arg) => ts.isObjectLiteralExpression(arg) && arg.properties.some((property) => ast.propertyName(property) === "guards"));
+  const chainOf = (initializer) => {
+    let root = unwrap(initializer);
+    const methods = [];
+    while (ts.isCallExpression(root) && ts.isPropertyAccessExpression(root.expression) && ts.isCallExpression(unwrap(root.expression.expression))) {
+      methods.push(root.expression.name.text);
+      root = unwrap(root.expression.expression);
+    }
+    return { root: ts.isCallExpression(root) ? root : null, methods };
+  };
+  const keyName = (property) => ts.isPropertyAssignment(property) || ts.isMethodDeclaration(property) || ts.isShorthandPropertyAssignment(property) ? property.name : null;
+  const objectKeys = (source, object) => (object?.properties ?? []).flatMap((property) => {
+    const name = ast.propertyName(property);
+    const node = keyName(property);
+    return name && node ? [{ name, span: spanOf(source, node), extent: extentOf(source, property) }] : [];
+  });
+  const sliceKeysOf = (source, builder) => (returnedObject(builder)?.properties ?? []).flatMap((property) => {
+    if (!ts.isPropertyAssignment(property))
+      return [];
+    const name = ast.nodeName(property.name);
+    if (!name)
+      return [];
+    const { root, methods } = chainOf(property.initializer);
+    return [
+      {
+        name,
+        span: spanOf(source, property.name),
+        extent: extentOf(source, property),
+        guards: root ? guardsIn(optionObjectOf(root)) : [],
+        live: methods.includes("live"),
+        argCount: methods.filter((method) => argMethods.has(method)).length
+      }
+    ];
+  });
+  const verbReaderOf = (parameter) => {
+    const verbs = new Map;
+    if (parameter && ts.isObjectBindingPattern(parameter.name))
+      for (const element of parameter.name.elements) {
+        const verb = element.propertyName ?? element.name;
+        if (ts.isIdentifier(verb) && ts.isIdentifier(element.name))
+          verbs.set(element.name.text, verb.text);
+      }
+    const holder = parameter && ts.isIdentifier(parameter.name) ? parameter.name.text : null;
+    return (callee) => {
+      if (callee && ts.isIdentifier(callee))
+        return verbs.get(callee.text) ?? null;
+      if (callee && ts.isPropertyAccessExpression(callee) && ts.isIdentifier(callee.expression) && callee.expression.text === holder)
+        return callee.name.text;
+      return null;
+    };
+  };
+  const endpointKeysOf = (source, builder) => {
+    const verbOf = verbReaderOf(builder?.parameters[0]);
+    return (returnedObject(builder)?.properties ?? []).flatMap((property) => {
+      if (!ts.isPropertyAssignment(property))
+        return [];
+      const name = ast.nodeName(property.name);
+      if (!name)
+        return [];
+      const { root, methods } = chainOf(property.initializer);
+      return [
+        {
+          name,
+          span: spanOf(source, property.name),
+          extent: extentOf(source, property),
+          verb: root ? verbOf(root.expression) : null,
+          guards: root ? guardsIn(optionObjectOf(root)) : [],
+          argCount: methods.filter((method) => argMethods.has(method)).length
+        }
+      ];
+    });
+  };
+  const filterQueriesOf = (source, builder) => {
+    const query = returnedObject(builder)?.properties.find((property) => ts.isPropertyAssignment(property) && ast.nodeName(property.name) === "query")?.initializer;
+    return query && ts.isObjectLiteralExpression(query) ? objectKeys(source, query) : [];
+  };
+  const typeOf = (expression) => {
+    const value = expression && unwrap(expression);
+    if (value && ts.isArrayLiteralExpression(value))
+      return { type: typeOf(value.elements[0]).type, array: true };
+    return { type: value ? ast.expressionName(value) : null, array: false };
+  };
+  const fieldsOf = (source, object) => (object?.properties ?? []).flatMap((property) => {
+    const name = ast.propertyName(property);
+    const node = keyName(property);
+    if (!name || !node)
+      return [];
+    const { root, methods } = ts.isPropertyAssignment(property) ? chainOf(property.initializer) : { root: null, methods: [] };
+    return [
+      {
+        name,
+        span: spanOf(source, node),
+        extent: extentOf(source, property),
+        ...typeOf(root?.arguments[0]),
+        optional: methods.includes("optional")
+      }
+    ];
+  });
+  const constantOf = (source, name, call) => {
+    const parents = call.arguments.map(unwrap).filter((arg) => ts.isIdentifier(arg) || ts.isPropertyAccessExpression(arg)).map((arg) => ast.expressionName(arg)).filter((parent) => parent !== null);
+    const fields = call.arguments.flatMap((arg) => fieldsOf(source, ast.firstObjectReturnedByArrow(arg)));
+    return { ...name, parents, fields };
+  };
+  const enumValuesOf = (call) => {
+    const list = call.arguments[1] && unwrap(call.arguments[1]);
+    if (!list || !ts.isArrayLiteralExpression(list))
+      return [];
+    return list.elements.flatMap((element) => ts.isStringLiteralLike(element) ? [element.text] : []);
+  };
+  const methodsOf = (source, statement) => statement.members.flatMap((member) => {
+    if (!ts.isMethodDeclaration(member) || !member.body)
+      return [];
+    const name = ast.nodeName(member.name);
+    if (!name || ts.getModifiers(member)?.some(({ kind }) => kind === ts.SyntaxKind.StaticKeyword))
+      return [];
+    return [{ name, span: spanOf(source, member.name), extent: extentOf(source, member) }];
+  });
+  const lowerFirst = (text) => text.charAt(0).toLowerCase() + text.slice(1);
+  const read = (source, owner) => {
+    const facts = {
+      fileName: source.fileName,
+      owner,
+      constants: [],
+      enums: [],
+      filters: [],
+      models: [],
+      services: [],
+      slices: [],
+      endpoints: [],
+      stores: []
+    };
+    for (const statement of source.statements) {
+      if (!ts.isClassDeclaration(statement) || !statement.name)
+        continue;
+      const heritage = ast.heritageCallNamed(statement, moduleCallees);
+      if (!heritage)
+        continue;
+      const { callee, call } = heritage;
+      const name = { name: statement.name.text, span: spanOf(source, statement.name) };
+      const builder = builderOf(call);
+      if (callee === "via")
+        facts.constants.push(constantOf(source, name, call));
+      else if (callee === "enumOf")
+        facts.enums.push({ ...name, values: enumValuesOf(call) });
+      else if (callee === "from")
+        facts.filters.push({ ...name, queries: filterQueriesOf(source, builder) });
+      else if (callee === "into")
+        facts.models.push({ ...name, model: name.name.endsWith("Model") ? lowerFirst(name.name.slice(0, -5)) : null });
+      else if (callee === "serve")
+        facts.services.push({
+          ...name,
+          model: moduleRefOf(call.arguments[0], "db"),
+          methods: methodsOf(source, statement)
+        });
+      else if (callee === "slice")
+        facts.slices.push({
+          ...name,
+          model: moduleRefOf(call.arguments[0], "srv"),
+          guards: guardsIn(call.arguments.find(ts.isObjectLiteralExpression)),
+          keys: sliceKeysOf(source, builder)
+        });
+      else if (callee === "endpoint")
+        facts.endpoints.push({
+          ...name,
+          model: moduleRefOf(call.arguments[0], "srv"),
+          keys: endpointKeysOf(source, builder)
+        });
+      else if (callee === "store")
+        facts.stores.push({
+          ...name,
+          model: moduleRefOf(call.arguments[0], "sig"),
+          stateKeys: objectKeys(source, returnedObject(builder)),
+          actions: methodsOf(source, statement)
+        });
+    }
+    return facts;
+  };
+  return { read, spanOf, moduleRefOf, chainOf, unwrap };
+};
+
+// 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 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);
+    this.#fileWords.set(fileName, `
+${[...new Set(text.match(wordPattern))].join(`
+`)}
+`);
+    if (!AkanIndex.isSourcePath(fileName))
+      return;
+    const source = this.#parsed.get(fileName)?.text === text ? this.#parse(fileName, text) : this.#parseUncached(fileName, text);
+    this.#facts.set(fileName, this.#reader.read(source, this.#ownerOf(fileName)));
+    this.#table = null;
+  }
+  removeFile(givenName) {
+    const fileName = pathOf(givenName);
+    this.#fileWords.delete(fileName);
+    this.#parsed.delete(fileName);
+    if (this.#facts.delete(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)
+    }).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 #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());
+    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) });