@turri-dev/cli 0.1.14-next.3e3ff53 → 0.1.14-next.678847f

package/dist/host.d.ts

@@ -1,8 +1,8 @@
 /**
  * turri for a host that runs it itself - a desktop app, an editor - imported as `@turri-dev/cli/host`: the
  * conversation as pi's extension, with the host told of its jobs and asking its questions (createTurriExtension), and
- * what a host shows beside it - a spec parsed, checked and coloured, how far each functional spec is built, the work a
- * spec change would plan. It is turri's own code, as the terminal runs it; a 0.x release may change any of it.
+ * what a host shows beside it - a spec parsed, checked and coloured, its concepts and links, the standard library, how
+ * far each functional spec is built, the work a spec change would plan. It is turri's own code, as the terminal runs it; a 0.x release may change any of it.
  */
 export { createTurriExtension, type TurriHost } from "./extension.ts";
 export type { AskUserIO } from "./ask.ts";
@@ -18,6 +18,10 @@ export { checkPlainFile, type CheckResult } from "./plain/check.ts";
 export { plainFileParser } from "./plain/parser.ts";
 export { FUNCTIONAL_REQUIREMENTS, iterateFunctionalSpecs } from "./plain/spec.ts";
 export { highlightLines, roleOf, type PlainRole } from "./plain/highlight.ts";
+export { conceptsOf, type ModuleConcept } from "./plain/module-concepts.ts";
+export { conceptBeingTyped, findConcepts } from "./plain/concepts.ts";
+export { plainGraph, type PlainConceptNode, type PlainGraph, type PlainItemNode, type PlainLink, type PlainModuleNode, type PlainSection } from "./plain/graph.ts";
+export { isStack, STDLIB_KINDS, stdlibTemplates, type StdlibKind, type StdlibTemplate } from "./stdlib.ts";
 export { createWorkLoop, describeModules, functionalityCompletion, promptOf, type DriftReport, type ModuleStatus, type WorkLoop } from "./regenerate/loop.ts";
 export { createJobRegistry, defaultParallelJobs, type Job, type JobRegistry } from "./regenerate/jobs.ts";
 export { describeTurnIncident, onModelEvent, type TranscriptEntry } from "./regenerate/activity.ts";

package/dist/host.js

@@ -1,8 +1,8 @@
 /**
  * turri for a host that runs it itself - a desktop app, an editor - imported as `@turri-dev/cli/host`: the
  * conversation as pi's extension, with the host told of its jobs and asking its questions (createTurriExtension), and
- * what a host shows beside it - a spec parsed, checked and coloured, how far each functional spec is built, the work a
- * spec change would plan. It is turri's own code, as the terminal runs it; a 0.x release may change any of it.
+ * what a host shows beside it - a spec parsed, checked and coloured, its concepts and links, the standard library, how
+ * far each functional spec is built, the work a spec change would plan. It is turri's own code, as the terminal runs it; a 0.x release may change any of it.
  */
 // The conversation.
 export { createTurriExtension } from "./extension.js";
@@ -25,6 +25,14 @@ export { checkPlainFile } from "./plain/check.js";
 export { plainFileParser } from "./plain/parser.js";
 export { FUNCTIONAL_REQUIREMENTS, iterateFunctionalSpecs } from "./plain/spec.js";
 export { highlightLines, roleOf } from "./plain/highlight.js";
+// Its concepts: those a module can name, with what each is and where it is defined, and those written in a piece of text.
+export { conceptsOf } from "./plain/module-concepts.js";
+export { conceptBeingTyped, findConcepts } from "./plain/concepts.js";
+// A project's ***plain as a graph: its modules and their links both ways, each item of their sections, the concepts
+// each names and where each is defined.
+export { plainGraph } from "./plain/graph.js";
+// The standard library: every template, what it is, what it imports, and its conformance template or stack.
+export { isStack, STDLIB_KINDS, stdlibTemplates } from "./stdlib.js";
 // The work: what is built, what is left, and the jobs that build it.
 export { createWorkLoop, describeModules, functionalityCompletion, promptOf } from "./regenerate/loop.js";
 export { createJobRegistry, defaultParallelJobs } from "./regenerate/jobs.js";

package/dist/plain/concepts.d.ts

@@ -1,8 +1,26 @@
 import { type AnyNode, type Section } from "./markdown.ts";
 import { type MarshalledPlainSource, type SpecificationItem } from "./spec.ts";
 /** Port of concept_utils.py. */
+/**
+ * ***plain's own concepts, each with what it means, in a line: every module can name them, and none may define them.
+ * turri's, not the reference parser's - it has only the names.
+ */
+export declare const DEFAULT_CONCEPT_DEFINITIONS: Readonly<Record<string, string>>;
 /** Reserved concept names that must not be redefined in the definitions section. */
 export declare const DEFAULT_CONCEPTS: Set<string>;
+/** Every concept written in a piece of text - `:User:` - with where it is, as the parser reads concepts in a spec. */
+export declare function findConcepts(text: string): Array<{
+    concept: string;
+    start: number;
+    end: number;
+}>;
+/** The concept being typed at the end of a piece of text - `:Us` - with where it starts, or undefined when there is none. */
+export declare function conceptBeingTyped(text: string): {
+    typed: string;
+    start: number;
+} | undefined;
+/** A definition's text after the concepts it defines: `is a person who signs up` of `- :User: is a person who signs up`. */
+export declare function definitionText(text: string): string;
 export declare function extractConceptsFromDefinition(text: string): [string[], string[]];
 export declare function extractConceptsFromSpecText(text: string): string[];
 export declare function collectConcepts(plainSource: MarshalledPlainSource): [string[], string[]];

package/dist/plain/concepts.js

@@ -2,23 +2,50 @@ import { PlainSyntaxError } from "./errors.js";
 import { renderToMarkdown } from "./markdown.js";
 import { ACCEPTANCE_TESTS, DEFINITIONS, FUNCTIONAL_REQUIREMENTS, NON_FUNCTIONAL_REQUIREMENTS, TEST_REQUIREMENTS, getSpecificationItems, } from "./spec.js";
 /** Port of concept_utils.py. */
+/**
+ * ***plain's own concepts, each with what it means, in a line: every module can name them, and none may define them.
+ * turri's, not the reference parser's - it has only the names.
+ */
+export const DEFAULT_CONCEPT_DEFINITIONS = {
+    ":ConformanceTests:": "the tests, written apart from the code, that check it conforms to the functional specs",
+    ":UnitTests:": "the unit tests written with the code of each functional spec",
+    ":AcceptanceTest:": "a test that checks one functional spec does what its acceptance tests say",
+    ":AcceptanceTests:": "the tests that check a functional spec does what its acceptance tests say",
+    ":Implementation:": "the software that implements the module's functional specs",
+    ":plainDefinitions:": "the content of the module's ***definitions*** section",
+    ":plainImplementationReqs:": "the content of the module's ***implementation reqs*** section",
+    ":plainFunctionality:": "the content of the module's ***functional specs*** section",
+    ":plainTestReqs:": "the content of the module's ***test reqs*** section",
+    ":plainImplementationCode:": "the code generated from the module",
+};
 /** Reserved concept names that must not be redefined in the definitions section. */
-export const DEFAULT_CONCEPTS = new Set([
-    ":ConformanceTests:",
-    ":UnitTests:",
-    ":AcceptanceTest:",
-    ":AcceptanceTests:",
-    ":Implementation:",
-    ":plainDefinitions:",
-    ":plainImplementationReqs:",
-    ":plainFunctionality:",
-    ":plainTestReqs:",
-    ":plainImplementationCode:",
-]);
+export const DEFAULT_CONCEPTS = new Set(Object.keys(DEFAULT_CONCEPT_DEFINITIONS));
+/** What a concept's name is made of, between its two colons. */
+const CONCEPT_CHARACTERS = "+\\-.0-9A-Z_a-z";
 const DEFINITION_PATTERN = /-\s(:[^:]+:)(?:,\s*:[^:]+:)*/;
 const CONCEPT_CANDIDATE_PATTERN = /:[^:]+:/g;
-const VALID_CONCEPT_PATTERN = /^:[+\-.0-9A-Z_a-z]+:/;
-const SPEC_CONCEPT_PATTERN = /:[+\-.0-9A-Z_a-z]+:/g;
+const VALID_CONCEPT_PATTERN = new RegExp(`^:[${CONCEPT_CHARACTERS}]+:`);
+const SPEC_CONCEPT_PATTERN = new RegExp(`:[${CONCEPT_CHARACTERS}]+:`, "g");
+const TYPED_CONCEPT_PATTERN = new RegExp(`:[${CONCEPT_CHARACTERS}]*$`);
+/** Every concept written in a piece of text - `:User:` - with where it is, as the parser reads concepts in a spec. */
+export function findConcepts(text) {
+    return [...text.matchAll(SPEC_CONCEPT_PATTERN)].map((match) => ({ concept: match[0], start: match.index, end: match.index + match[0].length }));
+}
+/** The concept being typed at the end of a piece of text - `:Us` - with where it starts, or undefined when there is none. */
+export function conceptBeingTyped(text) {
+    const match = TYPED_CONCEPT_PATTERN.exec(text);
+    if (match === null)
+        return undefined;
+    // A colon that closes a concept is not one that opens the next.
+    if (findConcepts(text).some(({ end }) => end - 1 === match.index))
+        return undefined;
+    return { typed: match[0], start: match.index };
+}
+/** A definition's text after the concepts it defines: `is a person who signs up` of `- :User: is a person who signs up`. */
+export function definitionText(text) {
+    const match = DEFINITION_PATTERN.exec(text);
+    return (match === null ? text : text.slice(match.index + match[0].length)).trim();
+}
 export function extractConceptsFromDefinition(text) {
     const match = DEFINITION_PATTERN.exec(text);
     if (!match) {

package/dist/plain/files.d.ts

@@ -1,5 +1,7 @@
 /** Ports of the Python reference implementation's file helpers this parser needs. */
 export declare function openFrom(dirs: string[], fileName: string): string | null;
+/** The file `openFrom` reads: the first of the folders that has it. */
+export declare function findIn(dirs: string[], fileName: string): string | null;
 /** First contiguous base64 blob at or above the threshold, or null. */
 export declare function findLargeBase64Blob(text: string): string | null;
 /**

package/dist/plain/files.js

@@ -3,16 +3,20 @@ import { join } from "node:path";
 import { createEnvironment } from "./liquid.js";
 /** Ports of the Python reference implementation's file helpers this parser needs. */
 export function openFrom(dirs, fileName) {
+    const path = findIn(dirs, fileName);
+    return path === null ? null : readFileSync(path, "utf8");
+}
+/** The file `openFrom` reads: the first of the folders that has it. */
+export function findIn(dirs, fileName) {
     for (const dir of dirs) {
         const fullPath = join(dir, fileName);
         try {
-            if (!statSync(fullPath).isFile())
-                continue;
+            if (statSync(fullPath).isFile())
+                return fullPath;
         }
         catch {
             continue;
         }
-        return readFileSync(fullPath, "utf8");
     }
     return null;
 }

package/dist/plain/graph.d.ts

@@ -0,0 +1,68 @@
+import { DEFINITIONS, FUNCTIONAL_REQUIREMENTS, NON_FUNCTIONAL_REQUIREMENTS, TEST_REQUIREMENTS } from "./spec.ts";
+/**
+ * A project's ***plain as a graph, to go from one place in it to another: its modules, each item of their sections,
+ * and the concepts - an item linked to its module, to the concepts it names and to where each is defined, a module to
+ * what it imports and requires and to what imports and requires it.
+ */
+export interface PlainGraph {
+    modules: PlainModuleNode[];
+    items: PlainItemNode[];
+    concepts: PlainConceptNode[];
+}
+/** A module one .plain file names, and the file it is - null when it is not found. */
+export interface PlainLink {
+    name: string;
+    file: string | null;
+}
+/** A .plain file: what it imports and requires, what imports and requires it, its items, and why it does not parse. */
+export interface PlainModuleNode {
+    file: string;
+    module: string;
+    /** Resolved as the parser reads an import: a standard library module from turri's `stdlib/`. */
+    imports: PlainLink[];
+    /** Resolved as the requires chain finds a required module. */
+    requires: PlainLink[];
+    importedBy: PlainLink[];
+    requiredBy: PlainLink[];
+    /** Its own items, in the order they are written: their ids. */
+    items: string[];
+    /** The parser's message, when the file does not parse. Its links are then what its front matter says, its items what of its own text reads. */
+    error?: string;
+}
+export type PlainSection = typeof DEFINITIONS | typeof NON_FUNCTIONAL_REQUIREMENTS | typeof TEST_REQUIREMENTS | typeof FUNCTIONAL_REQUIREMENTS;
+/** An item of a section, with what is nested under it - a functional spec with its acceptance tests. */
+export interface PlainItemNode {
+    /** `<file>:<line>`. */
+    id: string;
+    file: string;
+    module: string;
+    section: PlainSection;
+    /** The line it starts on, from 1. */
+    line: number;
+    text: string;
+    /** A functional spec's functionality id: `1`, `2`, ... */
+    frid?: string;
+    /** The concepts a definition defines. */
+    defines: string[];
+    /** The concepts it names, each with the definition it is - an item's id - or null for ***plain's own and one defined nowhere it can see. */
+    uses: Array<{
+        concept: string;
+        definition: string | null;
+    }>;
+}
+/** A concept as defined in one place - or ***plain's own - and every item that names it there. */
+export interface PlainConceptNode {
+    concept: string;
+    /** The item that defines it; null for ***plain's own. */
+    definition: string | null;
+    module: string | null;
+    /** The definition's text after its concepts. */
+    text: string;
+    usedBy: string[];
+}
+/**
+ * A project's ***plain as a graph: every .plain file in its folder and its `template/` folder, and every module they
+ * import or require, wherever the parser finds it, the standard library's too. Never throws: a file that does not
+ * parse is given with what its front matter says, what of its own text reads, and the error.
+ */
+export declare function plainGraph(projectDir: string): PlainGraph;

package/dist/plain/graph.js

@@ -0,0 +1,136 @@
+import { readdirSync, readFileSync } from "node:fs";
+import { basename, dirname, join, resolve } from "node:path";
+import { resolveTemplateDirs } from "../regenerate/paths.js";
+import { locateModule } from "../regenerate/requires.js";
+import { DEFAULT_CONCEPT_DEFINITIONS, DEFAULT_CONCEPTS, definitionText, extractConceptsFromDefinition, findConcepts } from "./concepts.js";
+import { lineNumber, renderToMarkdown } from "./markdown.js";
+import { attempt, namesIn, readModule } from "./module-concepts.js";
+import { IMPORT_DIRECTIVE, modulePlainFile, parsePlainFile, PLAIN_SOURCE_FILE_EXTENSION, plainFileParser, readPlainSourceMetadata, REQUIRES_DIRECTIVE, withParseCache, } from "./parser.js";
+import { DEFINITIONS, FUNCTIONAL_REQUIREMENTS, NON_FUNCTIONAL_REQUIREMENTS, TEST_REQUIREMENTS } from "./spec.js";
+import { isStdlibModule } from "./stdlib.js";
+const SECTIONS = [DEFINITIONS, NON_FUNCTIONAL_REQUIREMENTS, TEST_REQUIREMENTS, FUNCTIONAL_REQUIREMENTS];
+/**
+ * A project's ***plain as a graph: every .plain file in its folder and its `template/` folder, and every module they
+ * import or require, wherever the parser finds it, the standard library's too. Never throws: a file that does not
+ * parse is given with what its front matter says, what of its own text reads, and the error.
+ */
+export function plainGraph(projectDir) {
+    const root = resolve(projectDir);
+    // The folders a .plain file of the project is read with: its own, its template/ folder, PLAIN_TEMPLATE_DIRS.
+    const dirs = resolveTemplateDirs(join(root, `project${PLAIN_SOURCE_FILE_EXTENSION}`));
+    const modules = new Map();
+    const queue = [];
+    const visit = (file, module) => {
+        if (modules.has(file))
+            return;
+        const node = { file, module, imports: [], requires: [], importedBy: [], requiredBy: [], items: [] };
+        modules.set(file, node);
+        queue.push(node);
+    };
+    for (const dir of [root, join(root, "template")]) {
+        const names = attempt(() => readdirSync(dir).filter((name) => name.endsWith(PLAIN_SOURCE_FILE_EXTENSION)).sort()) ?? [];
+        for (const name of names)
+            visit(join(dir, name), basename(name, PLAIN_SOURCE_FILE_EXTENSION));
+    }
+    for (let node = queue.shift(); node !== undefined; node = queue.shift()) {
+        let metadata = {};
+        try {
+            metadata = readPlainSourceMetadata(readFileSync(node.file, "utf8")).metadata;
+        }
+        catch (error) {
+            node.error = messageOf(error);
+        }
+        node.imports = namesIn(metadata[IMPORT_DIRECTIVE]).map((name) => ({ name, file: modulePlainFile(name, dirs) }));
+        node.requires = namesIn(metadata[REQUIRES_DIRECTIVE]).map((name) => ({ name, file: attempt(() => locateModule(name, dirs)) ?? null }));
+        for (const link of [...node.imports, ...node.requires])
+            if (link.file !== null)
+                visit(link.file, link.name);
+    }
+    for (const node of modules.values()) {
+        for (const link of node.imports)
+            if (link.file !== null)
+                modules.get(link.file).importedBy.push({ name: node.module, file: node.file });
+        for (const link of node.requires)
+            if (link.file !== null)
+                modules.get(link.file).requiredBy.push({ name: node.module, file: node.file });
+    }
+    return withParseCache(() => {
+        const items = [];
+        const concepts = new Map();
+        for (const [concept, text] of Object.entries(DEFAULT_CONCEPT_DEFINITIONS))
+            concepts.set(`${concept}\0`, { concept, definition: null, module: null, text, usedBy: [] });
+        const lines = new Map();
+        const idOf = (node, file) => `${file}:${lineOf(node, file, lines)}`;
+        const fileOf = (module, node) => (module === node.module ? node.file : modulePlainFile(module, dirs));
+        for (const node of modules.values()) {
+            if (node.error === undefined)
+                node.error = parseError(node, dirs);
+            const read = readModule(node.module, node.file, dirs);
+            // Where each concept it can name is defined, the first definition winning, as the parser's checks find one.
+            const visible = new Map();
+            for (const { node: definition, module } of read.definitions) {
+                const file = fileOf(module, node);
+                if (file === null)
+                    continue;
+                const id = idOf(definition, file);
+                const text = renderToMarkdown(definition);
+                for (const concept of extractConceptsFromDefinition(text)[0]) {
+                    if (!visible.has(concept))
+                        visible.set(concept, id);
+                    if (!concepts.has(`${concept}\0${id}`))
+                        concepts.set(`${concept}\0${id}`, { concept, definition: id, module, text: definitionText(text), usedBy: [] });
+                }
+            }
+            for (const section of SECTIONS) {
+                const own = (read.parsed?.plainSource[section]?.children ?? []).filter((item) => !read.parsed.importedFrom.has(item));
+                own.forEach((item, index) => {
+                    const text = renderToMarkdown(item).trim();
+                    const defines = section === DEFINITIONS ? extractConceptsFromDefinition(text)[0] : [];
+                    const named = [...new Set(findConcepts(text).map((found) => found.concept))].filter((concept) => !defines.includes(concept));
+                    const id = idOf(item, node.file);
+                    const uses = named.map((concept) => ({ concept, definition: DEFAULT_CONCEPTS.has(concept) ? null : (visible.get(concept) ?? null) }));
+                    for (const use of uses)
+                        concepts.get(`${use.concept}\0${use.definition ?? ""}`)?.usedBy.push(id);
+                    items.push({ id, file: node.file, module: node.module, section, line: lineOf(item, node.file, lines), text, ...(section === FUNCTIONAL_REQUIREMENTS ? { frid: String(index + 1) } : {}), defines, uses });
+                    node.items.push(id);
+                });
+            }
+        }
+        return { modules: [...modules.values()], items, concepts: [...concepts.values()] };
+    });
+}
+/** Why a module does not parse: an import module as an import is parsed, a module of its own as one - functional specs or not yet. */
+function parseError(node, dirs) {
+    const imported = node.importedBy.length > 0 || isStdlibModule(node.module) || basename(dirname(node.file)) === "template";
+    try {
+        if (imported)
+            parsePlainFile(node.module, {}, dirs, [], []);
+        else
+            plainFileParser(`${node.module}${PLAIN_SOURCE_FILE_EXTENSION}`, dirs, { allowNoFunctionalities: true });
+        return undefined;
+    }
+    catch (error) {
+        return messageOf(error);
+    }
+}
+/**
+ * The line an item starts on in its file. The parser's is a line of the text after Liquid has run, which is the file's
+ * own unless an include or a tag changed the lines above it: then the first line of the file that has the item's
+ * first line is taken.
+ */
+function lineOf(node, file, cache) {
+    let lines = cache.get(file);
+    if (lines === undefined) {
+        lines = (attempt(() => readFileSync(file, "utf8")) ?? "").split(/\r?\n/);
+        cache.set(file, lines);
+    }
+    const at = lineNumber(node);
+    const first = renderToMarkdown(node).trim().split("\n")[0].replace(/^[-*+]\s+/, "").trim();
+    if (first === "" || lines[at - 1]?.includes(first))
+        return at;
+    const found = lines.findIndex((line) => line.includes(first));
+    return found === -1 ? at : found + 1;
+}
+function messageOf(error) {
+    return error instanceof Error ? error.message : String(error);
+}

package/dist/plain/module-concepts.d.ts

@@ -0,0 +1,32 @@
+import { type AnyNode } from "./markdown.ts";
+import { type PlainFileParseResult } from "./parser.ts";
+/** A concept a module can name, what it is, and the module that defines it - null for ***plain's own. */
+export interface ModuleConcept {
+    concept: string;
+    /** The definition's text after its concepts: `is a person who signs up`. */
+    definition: string;
+    module: string | null;
+}
+/** A module as the parser reads it, for what it names: its own parse, and every definition it can name. */
+export interface ReadModule {
+    /** Its parse, its imports merged in - or, when that fails, its own text read without them; undefined when neither reads. */
+    parsed?: PlainFileParseResult;
+    /** Its own definitions, those its imports bring and those its required modules export, each with the module it is written in. */
+    definitions: Array<{
+        node: AnyNode;
+        module: string;
+    }>;
+}
+/**
+ * A module read for what it can name, as the parser builds its definitions: its own, its imports' (`import`), and its
+ * required modules' `exported_concepts` with the definitions they use. Never throws: a module that does not parse
+ * gives its own definitions read without its imports, and what of those it names is there.
+ */
+export declare function readModule(moduleName: string, plainFile: string, templateDirs: string[]): ReadModule;
+/**
+ * Every concept a module can name: its own definitions, those its imports bring, those its required modules export,
+ * and ***plain's own - read as the parser reads them. A module that does not parse gives what can be read of it.
+ */
+export declare function conceptsOf(plainFile: string, templateDirs?: string[]): ModuleConcept[];
+export declare function attempt<T>(run: () => T): T | undefined;
+export declare function namesIn(value: unknown): string[];

package/dist/plain/module-concepts.js

@@ -0,0 +1,79 @@
+import { readFileSync } from "node:fs";
+import { basename } from "node:path";
+import { resolveTemplateDirs } from "../regenerate/paths.js";
+import { DEFAULT_CONCEPT_DEFINITIONS, definitionText, extractConceptsFromDefinition } from "./concepts.js";
+import { renderToMarkdown } from "./markdown.js";
+import { exportedDefinitionsOf, IMPORT_DIRECTIVE, parsePlainFile, parsePlainSource, PLAIN_SOURCE_FILE_EXTENSION, readPlainSourceMetadata, REQUIRES_DIRECTIVE, restoreStrippedLines, } from "./parser.js";
+import { DEFINITIONS } from "./spec.js";
+/**
+ * A module read for what it can name, as the parser builds its definitions: its own, its imports' (`import`), and its
+ * required modules' `exported_concepts` with the definitions they use. Never throws: a module that does not parse
+ * gives its own definitions read without its imports, and what of those it names is there.
+ */
+export function readModule(moduleName, plainFile, templateDirs) {
+    const parse = (name) => attempt(() => parsePlainFile(name, {}, templateDirs, [], []));
+    const definitions = [];
+    const add = (result, nodes, module) => {
+        for (const node of nodes)
+            definitions.push({ node, module: result.importedFrom.get(node) ?? module });
+    };
+    const definitionsOf = (result) => result.plainSource[DEFINITIONS]?.children ?? [];
+    let requires;
+    let parsed = parse(moduleName);
+    if (parsed !== undefined) {
+        add(parsed, definitionsOf(parsed), moduleName);
+        requires = parsed.requiredModules;
+    }
+    else {
+        // What its front matter names, each read on its own, and its own text without them.
+        const text = attempt(() => readFileSync(plainFile, "utf8"));
+        const front = text === undefined ? undefined : attempt(() => readPlainSourceMetadata(text));
+        for (const name of namesIn(front?.metadata[IMPORT_DIRECTIVE])) {
+            const imported = parse(name);
+            if (imported !== undefined)
+                add(imported, definitionsOf(imported), name);
+        }
+        parsed = front && attempt(() => parsePlainSource(restoreStrippedLines(text, front.content), {}, templateDirs, [], [moduleName]));
+        if (parsed !== undefined)
+            add(parsed, definitionsOf(parsed), moduleName);
+        requires = namesIn(front?.metadata[REQUIRES_DIRECTIVE]);
+    }
+    for (const name of requires) {
+        const required = parse(name);
+        const exported = required && attempt(() => exportedDefinitionsOf(required));
+        if (required !== undefined && exported !== undefined)
+            add(required, exported, name);
+    }
+    return { ...(parsed !== undefined ? { parsed } : {}), definitions };
+}
+/**
+ * Every concept a module can name: its own definitions, those its imports bring, those its required modules export,
+ * and ***plain's own - read as the parser reads them. A module that does not parse gives what can be read of it.
+ */
+export function conceptsOf(plainFile, templateDirs = resolveTemplateDirs(plainFile)) {
+    const found = [];
+    const seen = new Set();
+    for (const { node, module } of readModule(basename(plainFile, PLAIN_SOURCE_FILE_EXTENSION), plainFile, templateDirs).definitions) {
+        const text = renderToMarkdown(node);
+        for (const concept of extractConceptsFromDefinition(text)[0]) {
+            if (seen.has(`${concept}\0${module}`))
+                continue;
+            seen.add(`${concept}\0${module}`);
+            found.push({ concept, definition: definitionText(text), module });
+        }
+    }
+    for (const [concept, definition] of Object.entries(DEFAULT_CONCEPT_DEFINITIONS))
+        found.push({ concept, definition, module: null });
+    return found;
+}
+export function attempt(run) {
+    try {
+        return run();
+    }
+    catch {
+        return undefined;
+    }
+}
+export function namesIn(value) {
+    return Array.isArray(value) ? value.filter((name) => typeof name === "string") : [];
+}

package/dist/plain/parser.d.ts

@@ -16,6 +16,8 @@ export interface PlainFileParseResult {
     plainSourceObj: FrontmatterPost;
     requiredModules: string[];
     requiredConcepts: string[];
+    /** The items its imports brought into its sections, each with the module it is written in. turri's: the Python parser does not keep it. */
+    importedFrom: Map<AnyNode, string>;
 }
 export declare function getFilenameFromModuleName(moduleName: string): string;
 export declare function getModuleNameFromFilename(filename: string): string;
@@ -57,9 +59,16 @@ export declare function normalizeLineEndings(plainSourceText: string): string;
 export declare function restoreStrippedLines(plainSourceText: string, content: string): string;
 export declare function readPlainSourceMetadata(plainSourceText: string): FrontmatterPost;
 export declare function parsePlainSource(plainSourceText: string, codeVariables: Record<string, Record<string, string>>, templateDirs: string[], importedModules: string[], modulesTrace: string[]): PlainFileParseResult;
+/**
+ * The file a module name is read from, as `readModulePlainSource` reads it - a standard library module's in turri's
+ * `stdlib/`, any other's in the first template folder that has it - or null when there is none.
+ */
+export declare function modulePlainFile(moduleName: string, templateDirs: string[]): string | null;
 export declare function readModulePlainSource(moduleName: string, templateDirs: string[]): string;
 export declare function parsePlainFile(moduleName: string, codeVariables: Record<string, Record<string, string>>, templateDirs: string[], importedModules: string[], modulesTrace: string[]): PlainFileParseResult;
 export declare function processRequiredModules(requiredModules: string[], codeVariables: Record<string, Record<string, string>>, templateDirs: string[], allRequiredModules: string[], modulesTrace: string[]): AnyNode[];
+/** The definitions a required module exports: those of its `exported_concepts`, with the definitions they use. */
+export declare function exportedDefinitionsOf(result: PlainFileParseResult): AnyNode[];
 export declare function processExportedDefinitions(plainSource: ParsedPlainSource, exportedDefinitions: AnyNode[]): void;
 /**
  * Parse a .plain file into the marshalled tree.

package/dist/plain/parser.js

@@ -4,9 +4,9 @@ import { extname, isAbsolute, basename, resolve } from "node:path";
 import { load as loadYaml } from "js-yaml";
 import { extractConceptsFromDefinition, findConceptDefinitionsInPlainSource, sortDefinitions, validateConcepts, DEFAULT_CONCEPTS, } from "./concepts.js";
 import { ImportedModuleWithFunctionalitiesError, MissingFunctionalitiesError, ModuleDoesNotExistError, PlainSyntaxError, UnsupportedBase64Content, } from "./errors.js";
-import { findLargeBase64Blob, getLoadedTemplates, openFrom } from "./files.js";
+import { findIn, findLargeBase64Blob, getLoadedTemplates, openFrom } from "./files.js";
 import { renderPlainSource } from "./liquid.js";
-import { isStdlibModule, readStdlibModule } from "./stdlib.js";
+import { isStdlibModule, readStdlibModule, stdlibModuleFile } from "./stdlib.js";
 import { getRawText, lineNumber, parseMarkdown, removeQuotes, renderToMarkdown, traverse, } from "./markdown.js";
 import { ACCEPTANCE_TESTS, ACCEPTANCE_TEST_HEADING, ALLOWED_IMPORT_SPECIFICATION_HEADINGS, ALLOWED_SPECIFICATION_HEADINGS, DEFINITIONS, FUNCTIONAL_REQUIREMENTS, NON_FUNCTIONAL_REQUIREMENTS, TEST_REQUIREMENTS, getSpecificationItems, REQUIRED_FUNCTIONAL_SPECS, } from "./spec.js";
 export const IMPORT_DIRECTIVE = "import";
@@ -366,7 +366,7 @@ export function readPlainSourceMetadata(plainSourceText) {
     }
     return { metadata, content };
 }
-function processImports(plainSource, imports, codeVariables, templateDirs, importedModules, modulesTrace) {
+function processImports(plainSource, imports, codeVariables, templateDirs, importedModules, modulesTrace, importedFrom) {
     const requiredConcepts = [];
     for (const moduleName of imports) {
         if (modulesTrace.includes(moduleName)) {
@@ -380,6 +380,10 @@ function processImports(plainSource, imports, codeVariables, templateDirs, impor
                 "Imported modules may only provide definitions, implementation reqs, and test reqs — " +
                 "use 'requires' instead of 'import' if this module's functionalities should be built on.");
         }
+        for (const section of Object.values(result.plainSource)) {
+            for (const item of section?.children ?? [])
+                importedFrom.set(item, result.importedFrom.get(item) ?? moduleName);
+        }
         for (const heading of Object.keys(result.plainSource)) {
             if (!ALLOWED_IMPORT_SPECIFICATION_HEADINGS.includes(heading)) {
                 throw new PlainSyntaxError(`Plain syntax error: Invalid specification heading (\`${heading}\`). ` +
@@ -411,8 +415,9 @@ export function parsePlainSource(plainSourceText, codeVariables, templateDirs, i
     const plainSourceObj = readPlainSourceMetadata(plainSourceText);
     const plainSource = newPlainSource();
     let requiredConcepts = [];
+    const importedFrom = new Map();
     if (IMPORT_DIRECTIVE in plainSourceObj.metadata) {
-        requiredConcepts = processImports(plainSource, plainSourceObj.metadata[IMPORT_DIRECTIVE], codeVariables, templateDirs, importedModules, modulesTrace);
+        requiredConcepts = processImports(plainSource, plainSourceObj.metadata[IMPORT_DIRECTIVE], codeVariables, templateDirs, importedModules, modulesTrace, importedFrom);
     }
     const [, loadedTemplates] = getLoadedTemplates(templateDirs, plainSourceText);
     const plainSourceContent = restoreStrippedLines(plainSourceText, plainSourceObj.content);
@@ -490,7 +495,14 @@ export function parsePlainSource(plainSourceText, codeVariables, templateDirs, i
         }
     }
     const requiredModules = plainSourceObj.metadata[REQUIRES_DIRECTIVE] ?? [];
-    return { plainSource, plainSourceObj, requiredModules, requiredConcepts };
+    return { plainSource, plainSourceObj, requiredModules, requiredConcepts, importedFrom };
+}
+/**
+ * The file a module name is read from, as `readModulePlainSource` reads it - a standard library module's in turri's
+ * `stdlib/`, any other's in the first template folder that has it - or null when there is none.
+ */
+export function modulePlainFile(moduleName, templateDirs) {
+    return isStdlibModule(moduleName) ? stdlibModuleFile(moduleName) : findIn(templateDirs, moduleName + PLAIN_SOURCE_FILE_EXTENSION);
 }
 export function readModulePlainSource(moduleName, templateDirs) {
     // `stdlib/...` is turri's standard library, and only that - see stdlib.ts.
@@ -536,27 +548,29 @@ export function processRequiredModules(requiredModules, codeVariables, templateD
                 moduleName,
             ]);
         }
-        if (EXPORTED_CONCEPTS_DIRECTIVE in result.plainSourceObj.metadata) {
-            const exportedConcepts = [];
-            for (const concept of result.plainSourceObj.metadata[EXPORTED_CONCEPTS_DIRECTIVE]) {
-                if (typeof concept === "string" && DEFAULT_CONCEPTS.has(concept)) {
-                    throw new PlainSyntaxError(`Plain syntax error: Default concept cannot be exported: ${concept}. Only user-defined concepts can be exported.`);
-                }
-                if (typeof concept === "string") {
-                    exportedConcepts.push(...extractConceptsFromDefinition(concept)[0]);
-                }
-                else {
-                    throw new PlainSyntaxError(`Plain syntax error: Invalid exported concept: ${concept}.`);
-                }
-            }
-            for (const exportedConcept of exportedConcepts) {
-                exportedDefinitions.push(...findConceptDefinitionsInPlainSource(exportedConcept, result.plainSource[DEFINITIONS] ?? null));
-            }
-        }
+        exportedDefinitions.push(...exportedDefinitionsOf(result));
         allRequiredModules.push(moduleName);
     }
     return exportedDefinitions;
 }
+/** The definitions a required module exports: those of its `exported_concepts`, with the definitions they use. */
+export function exportedDefinitionsOf(result) {
+    if (!(EXPORTED_CONCEPTS_DIRECTIVE in result.plainSourceObj.metadata))
+        return [];
+    const exportedConcepts = [];
+    for (const concept of result.plainSourceObj.metadata[EXPORTED_CONCEPTS_DIRECTIVE]) {
+        if (typeof concept === "string" && DEFAULT_CONCEPTS.has(concept)) {
+            throw new PlainSyntaxError(`Plain syntax error: Default concept cannot be exported: ${concept}. Only user-defined concepts can be exported.`);
+        }
+        if (typeof concept === "string") {
+            exportedConcepts.push(...extractConceptsFromDefinition(concept)[0]);
+        }
+        else {
+            throw new PlainSyntaxError(`Plain syntax error: Invalid exported concept: ${concept}.`);
+        }
+    }
+    return exportedConcepts.flatMap((exportedConcept) => findConceptDefinitionsInPlainSource(exportedConcept, result.plainSource[DEFINITIONS] ?? null));
+}
 export function processExportedDefinitions(plainSource, exportedDefinitions) {
     if (exportedDefinitions.length === 0)
         return;

package/dist/plain/stdlib.d.ts

@@ -10,5 +10,7 @@ export declare const STDLIB_PREFIX = "stdlib/";
 /** The folder `stdlib/` is in: turri's own. */
 export declare const STDLIB_ROOT: string;
 export declare function isStdlibModule(moduleName: string): boolean;
+/** A standard library module's file, or null when the standard library has no such module. */
+export declare function stdlibModuleFile(moduleName: string): string | null;
 /** A standard library module's text - refused when a folder the spec is resolved from has a module of that name too. */
 export declare function readStdlibModule(moduleName: string, templateDirs: string[]): string;

package/dist/plain/stdlib.js

@@ -2,7 +2,7 @@ import { existsSync, realpathSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 import { ModuleDoesNotExistError, PlainSyntaxError } from "./errors.js";
-import { openFrom } from "./files.js";
+import { findIn, openFrom } from "./files.js";
 /**
  * The ***plain standard library's names. `stdlib/` is a reserved prefix: `stdlib/backend/python-fastapi`
  * is always turri's own template, in its `stdlib/` folder - never a module of the project's. A
@@ -25,6 +25,10 @@ function sameFile(a, b) {
         return false;
     }
 }
+/** A standard library module's file, or null when the standard library has no such module. */
+export function stdlibModuleFile(moduleName) {
+    return findIn([STDLIB_ROOT], `${moduleName.replace(/^\.\//, "")}.plain`);
+}
 /** A standard library module's text - refused when a folder the spec is resolved from has a module of that name too. */
 export function readStdlibModule(moduleName, templateDirs) {
     const name = moduleName.replace(/^\.\//, "");

package/dist/regenerate/requires.d.ts

@@ -18,6 +18,8 @@ export interface ChainEntry {
     requires: string | null;
     frids: string[];
 }
+/** A required module's file: the first template folder that has it. */
+export declare function locateModule(moduleName: string, templateDirs: string[]): string;
 /**
  * The chain to build, bottom first.
  *

package/dist/regenerate/requires.js

@@ -8,7 +8,8 @@ import { resolveTemplateDirs } from "./paths.js";
 import { inheritedRecord, readRecord, RECORD_FILE, writeCodeRecord } from "./records.js";
 import { head, historyLog, recordHistory } from "./lineage.js";
 import { listFiles } from "./testing.js";
-function locateModule(moduleName, templateDirs) {
+/** A required module's file: the first template folder that has it. */
+export function locateModule(moduleName, templateDirs) {
     for (const dir of templateDirs) {
         const candidate = join(dir, moduleName + PLAIN_SOURCE_FILE_EXTENSION);
         if (existsSync(candidate))

package/dist/stdlib.d.ts

@@ -7,14 +7,30 @@
 export interface StdlibTemplate {
     /** What a spec imports it as: `stdlib/backend/python-fastapi`. */
     name: string;
+    /** Where it is: turri's `stdlib/backend/python-fastapi.plain`. */
+    file: string;
+    /** The kind of software it is for - `backend`, `frontend`, `cli`, `library` - or `lang`, a language's. */
+    kind: StdlibKind;
     description: string;
     text: string;
+    /** The modules its front matter imports, as the parser reads it. */
+    imports: string[];
+    /** A stack's conformance template, when it has one: `stdlib/backend/conformance/python-fastapi`. */
+    conformance?: string;
+    /** A conformance template's stack, when it is one's: `stdlib/backend/python-fastapi`. */
+    tests?: string;
 }
+export type StdlibKind = "backend" | "frontend" | "cli" | "library" | "lang";
 export declare function stdlibTemplates(dir?: string): StdlibTemplate[];
 /** A stack to import - not a kind's `common`, not a conformance template, and not a language's. */
 export declare function isStack(template: StdlibTemplate): boolean;
 /** A stack's conformance template: `stdlib/backend/python-fastapi` has `stdlib/backend/conformance/python-fastapi`. */
 export declare function conformanceOf(stack: string): string;
+/** The standard library's kinds, in the order they are listed, each with its title. Only the first four have stacks. */
+export declare const STDLIB_KINDS: ReadonlyArray<{
+    kind: StdlibKind;
+    title: string;
+}>;
 /**
  * The catalogue appended to the stdlib rule: every stack with its conformance template and what it is, the
  * shared templates, and the folder they are all in - an absolute path, so an agent reads the one it imports

package/dist/stdlib.js

@@ -1,5 +1,6 @@
 import { readdirSync, readFileSync } from "node:fs";
 import { join, relative, sep } from "node:path";
+import { IMPORT_DIRECTIVE, readPlainSourceMetadata } from "./plain/parser.js";
 import { STDLIB_DIR } from "./regenerate/paths.js";
 export function stdlibTemplates(dir = STDLIB_DIR) {
     const found = [];
@@ -19,16 +20,31 @@ export function stdlibTemplates(dir = STDLIB_DIR) {
         }
     };
     walk(dir);
-    return found
+    const templates = found
         .map((file) => {
         const text = readFileSync(file, "utf8").trim();
-        return {
-            name: `stdlib/${relative(dir, file).split(sep).join("/").replace(/\.plain$/, "")}`,
-            description: /^description:\s*(.+)$/m.exec(text)?.[1]?.trim() ?? "",
-            text,
-        };
+        const name = `stdlib/${relative(dir, file).split(sep).join("/").replace(/\.plain$/, "")}`;
+        return { name, file, kind: name.split("/")[1], description: /^description:\s*(.+)$/m.exec(text)?.[1]?.trim() ?? "", text, imports: importsOf(text) };
     })
         .sort((a, b) => a.name.localeCompare(b.name));
+    const names = new Set(templates.map((template) => template.name));
+    for (const template of templates) {
+        if (isStack(template) && names.has(conformanceOf(template.name)))
+            template.conformance = conformanceOf(template.name);
+        const stack = template.name.replace("/conformance/", "/");
+        if (template.name.includes("/conformance/") && templates.some((other) => other.name === stack && isStack(other)))
+            template.tests = stack;
+    }
+    return templates;
+}
+function importsOf(text) {
+    try {
+        const imports = readPlainSourceMetadata(text).metadata[IMPORT_DIRECTIVE];
+        return Array.isArray(imports) ? imports.filter((name) => typeof name === "string") : [];
+    }
+    catch {
+        return [];
+    }
 }
 /** A stack to import - not a kind's `common`, not a conformance template, and not a language's. */
 export function isStack(template) {
@@ -39,11 +55,13 @@ export function conformanceOf(stack) {
     const slash = stack.lastIndexOf("/");
     return `${stack.slice(0, slash)}/conformance/${stack.slice(slash + 1)}`;
 }
-const KINDS = [
+/** The standard library's kinds, in the order they are listed, each with its title. Only the first four have stacks. */
+export const STDLIB_KINDS = [
     { kind: "backend", title: "Backends" },
     { kind: "frontend", title: "Frontends" },
     { kind: "cli", title: "Command-line tools" },
     { kind: "library", title: "Libraries" },
+    { kind: "lang", title: "Languages" },
 ];
 /**
  * The catalogue appended to the stdlib rule: every stack with its conformance template and what it is, the
@@ -61,7 +79,7 @@ export function stdlibCatalogue(templates = stdlibTemplates(), dir = STDLIB_DIR)
         "",
         `Every template is a file in ${dir}: \`stdlib/backend/python-fastapi\` is \`${dir}/backend/python-fastapi.plain\`. Read the ones a module imports - the stack, its language, its kind's \`common\`, and their conformance templates - before writing its specs.`,
         "",
-        ...KINDS.flatMap(({ kind, title }) => {
+        ...STDLIB_KINDS.flatMap(({ kind, title }) => {
             const stacks = templates.filter((template) => isStack(template) && template.name.startsWith(`stdlib/${kind}/`));
             return stacks.length === 0 ? [] : [`### ${title}`, "", "| import | its conformance tests | what it is |", "| --- | --- | --- |", ...stacks.map(row), ""];
         }),
@@ -85,7 +103,7 @@ export function describeStdlib(templates = stdlibTemplates(), dir = STDLIB_DIR)
     const width = Math.max(...templates.filter(isStack).map((template) => template.name.length));
     return [
         `The ***plain standard library - ${stdlibStackCount(templates)} stacks a spec can import instead of writing its implementation reqs:`,
-        ...KINDS.flatMap(({ kind, title }) => {
+        ...STDLIB_KINDS.flatMap(({ kind, title }) => {
             const stacks = templates.filter((template) => isStack(template) && template.name.startsWith(`stdlib/${kind}/`));
             return stacks.length === 0 ? [] : ["", `${title}:`, ...stacks.map((template) => `  ${template.name.padEnd(width)}  ${template.description}`)];
         }),

package/docs/hosting.md

@@ -18,6 +18,9 @@
 | `bedrockAwsRegion`, `bedrockNeedsAwsRegion` | the AWS region to set `AWS_REGION` to for a Bedrock geography, and whether it has to be set. |
 | `checkPlainFile`, `plainFileParser`, `resolveTemplateDirs`, `iterateFunctionalSpecs`, `FUNCTIONAL_REQUIREMENTS` | \*\*\*plain checked and parsed, its functional specs one by one - as `turri validate` reads it. |
 | `highlightLines`, `roleOf` | \*\*\*plain's lines coloured by turri's own [\*\*\*plain](https://plainlang.org/docs/) grammar. |
+| `plainGraph(projectDir)` | a project's \*\*\*plain as a graph to move around in: its modules with what each imports and requires and what imports and requires it, each item of their sections with its line, and the concepts - an item linked to those it names and to where each is defined - see [\*\*\*plain for a host](#plain-for-a-host). |
+| `conceptsOf(plainFile)`, `findConcepts(text)`, `conceptBeingTyped(text)` | the concepts a module can name, with what each is and the module that defines it; the concepts written in a piece of text; the one being typed at its end. |
+| `stdlibTemplates()`, `isStack`, `STDLIB_KINDS` | turri's standard library: every template with its kind, file, text, imports and its conformance template or the stack it tests, and the kinds in order with their titles. |
 | `functionalityCompletion`, `createWorkLoop`, `createJobRegistry`, `promptOf`, `describeModules` | how far each functional spec is built, and - on a loop of the host's own with `dryRun` - the work a \*\*\*plain change would plan, as `turri glimpse` does. |
 | `onModelEvent`, `describeTurnIncident` | a provider failing and waited out, a turn turri ended itself. |
 | `onLedgerEvent`, `readLedger`, `ledgerDir`, `runViews`, `pulseView`, `describePulseView`, `describeRuns`, `ledgerProjects`, `earlierPulses`, `asJob` | what turri did, as facts - the [ledger](using.md#the-ledger): each event heard as it is recorded, and every run and pulse read back, earlier sessions' too - see [the ledger in a host](#the-ledger-in-a-host). |
@@ -108,6 +111,27 @@ the chat, and the toolbar's buttons send them too.
 - The Run button releases what is built and opens it.`;
 ```
 
+## \*\*\*plain for a host
+
+```js
+import { conceptBeingTyped, conceptsOf, findConcepts, plainGraph, stdlibTemplates, STDLIB_KINDS } from "@turri-dev/cli/host";
+
+const { modules, items, concepts } = plainGraph(projectDir);
+const app = modules.find((module) => module.module === "app");
+app.requires;      // [{ name: "base", file: "/…/base.plain" }] - and imports, importedBy, requiredBy, the same way
+app.items;         // ["/…/app.plain:11", "/…/app.plain:15"] - its own items, in order
+items.find((item) => item.id === app.items[1]);
+// { id, file, module: "app", section: "functional specs", line: 15, frid: "1", text: "- :User: can fill :Cart:.",
+//   defines: [], uses: [{ concept: ":User:", definition: "/…/base.plain:8" }, { concept: ":Cart:", definition: "/…/app.plain:11" }] }
+concepts.find((concept) => concept.definition === "/…/base.plain:8");
+// { concept: ":User:", definition: "/…/base.plain:8", module: "base", text: "is a person who signs up.", usedBy: [...] }
+```
+
+- **The graph.** `plainGraph` reads every .plain file in the project's folder and its `template/` folder, and every module they import or require, wherever the parser finds it - the standard library's templates too. A **module** is a file: its imports, resolved as the parser reads an import (a `stdlib/` module from turri's own folder), its required modules, resolved as the requires chain finds them - `file: null` when one is not found - and the reverse of both, `importedBy` and `requiredBy`, so a host goes up and down the requires chain without inverting anything. An **item** is one item of a section - a definition, an implementation req, a test req, a functional spec with its acceptance tests - with its file, the line it starts on, its text, a functional spec's `frid`, the concepts a definition defines, and each concept it names with the item that defines it: its own module's definitions, its imports', and those its required modules export, as the parser sees them from that module. `definition` is null for \*\*\*plain's own concepts, and for one defined nowhere the module can see. A **concept** is one definition of it - or \*\*\*plain's own, `definition: null` - with every item that names it there. An item's id is `<file>:<line>`: the file to open and the line to go to.
+- **What does not parse.** Nothing throws. A file that does not parse has `error`, the parser's message; its links are what its front matter says, and its items what of its own text reads without its imports. A file whose items Liquid moves keeps the lines of its own text.
+- **Concepts.** `conceptsOf(plainFile)` is what one module can name - `{ concept, definition, module }`, `definition` the text after its concepts, `module` null for \*\*\*plain's own - for suggestions as the person types. `findConcepts(text)` is every concept written in a piece of text, `{ concept, start, end }`, and `conceptBeingTyped(text)` the one at its end still open - `{ typed: ":Us", start }`, or undefined - both with the parser's own pattern.
+- **The standard library.** `stdlibTemplates()` is every template in turri's `stdlib/`, sorted: `name` - what a module imports it as - `file`, `kind` (`backend`, `frontend`, `cli`, `library` or `lang`), `description`, `text`, `imports` as the parser reads its front matter, a stack's `conformance` template when it has one, and a conformance template's stack as `tests`. `isStack(template)` says whether it is a stack to import; `STDLIB_KINDS` is the kinds in order, each with its title.
+
 ## The ledger in a host
 
 The conversation's extension starts the ledger itself, in the folder the host made the session in - so a host that runs it there, the project's, needs nothing to have one: its pulses are recorded as `host` runs, and the conversation's `pulses` and `diagnose` already tell the model of earlier sessions' pulses. What the host can do with it is show it.

package/docs/parser.md

@@ -10,6 +10,7 @@
 | `src/plain/markdown.ts` | mistletoe's AST + `PlainRenderer` (mdast + a matching serializer) |
 | `src/plain/liquid.ts` | the reference implementation's Liquid nodes + the two filters in `plain_spec.py` (liquidjs) |
 | `src/plain/files.ts` | `file_utils.open_from` / `get_loaded_templates`, base64 blob detection |
+| `src/plain/module-concepts.ts`, `src/plain/graph.ts` | nothing - turri's own, for a host: the concepts a module can name and where each is defined, and a project's \*\*\*plain as a graph of modules, items and concepts (see [hosting](hosting.md#plain-for-a-host)). The parser keeps, beside the reference's result, which module each item an import brought is written in (`importedFrom`) |
 | `src/plain/stdlib.ts` | nothing - turri's own: `stdlib/` is a reserved import prefix, read from turri's standard library only, and a project module at such a path is an error (see [the standard library](authoring-plain.md#the-standard-library)) |
 
 ## Checking \*\*\*plain

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@turri-dev/cli",
-  "version": "0.1.14-next.3e3ff53",
+  "version": "0.1.14-next.678847f",
   "license": "MIT",
   "type": "module",
   "repository": {