@akanjs/language 0.0.0-stage → 3.1.2-rc.0

package/index.js

@@ -0,0 +1,1034 @@
+// 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"]);
+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 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) }] : [];
+  });
+  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),
+        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),
+          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 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) => objectKeys(source, ast.firstObjectReturnedByArrow(arg)));
+    return { ...name, parents, fields };
+  };
+  const lowerFirst = (text) => text.charAt(0).toLowerCase() + text.slice(1);
+  const read = (source, owner) => {
+    const facts = {
+      fileName: source.fileName,
+      owner,
+      constants: [],
+      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 === "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") });
+      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))
+        });
+    }
+    return facts;
+  };
+  return { read, spanOf, moduleRefOf, chainOf, unwrap };
+};
+
+// pkgs/akanjs/common/capitalize.ts
+var capitalize = (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] = [capitalize(refName), capitalize(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 = capitalize(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 = capitalize(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 = capitalize(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 = capitalize(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 = capitalize(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${capitalize(key)}`;
+var endpointNames = (key) => {
+  const Key = capitalize(key);
+  return { subscribe: `subscribe${Key}`, listen: `listen${Key}` };
+};
+
+// pkgs/@akanjs/language/nameTable.ts
+var capitalize2 = (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 = capitalize2(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);
+  }
+  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));
+  }
+}
+export {
+  AkanIndex,
+  createAst,
+  createFactReader,
+  ownerOf
+};