@zenera/rag 1.1.0

package/dist/present.js

@@ -0,0 +1,40 @@
+import { toOpenApi, toTypeScript } from "./schema/hydrate.js";
+import { render } from "./schema/render.js";
+// ---------------------------------------------------------------------------
+// One subgraph, in whichever of the four shapes was asked for
+//
+// The command, the prompt loop and the agent tool all print through here, so
+// `--format ts` from a shell and `format: "ts"` from a model are the same
+// bytes. Two of the four need the schemas off disk and two do not, which is
+// the only reason this is async.
+// ---------------------------------------------------------------------------
+export const FORMATS = ['text', 'mermaid', 'mermaid-flowchart', 'ts', 'openapi'];
+export function isFormat(value) {
+    return FORMATS.includes(value);
+}
+export async function present(index, subgraphs, format, options = {}) {
+    if (subgraphs.length === 0) {
+        return format === 'openapi' ? '{}' : '';
+    }
+    if (format === 'ts') {
+        const schemas = await index.schemas();
+        return subgraphs.map((s) => toTypeScript(s, schemas, options)).join('\n');
+    }
+    if (format === 'openapi') {
+        const [schemas, operations] = await Promise.all([index.schemas(), index.operations()]);
+        // One document for the whole answer: several would each have to repeat
+        // the components the others also touched.
+        const merged = subgraphs.reduce((all, one) => ({
+            nodes: [...all.nodes, ...one.nodes],
+            edges: [...all.edges, ...one.edges],
+            hits: [...all.hits, ...one.hits],
+            score: all.score + one.score,
+            truncated: all.truncated || one.truncated,
+        }), { nodes: [], edges: [], hits: [], score: 0, truncated: false });
+        return JSON.stringify(toOpenApi(merged, schemas, operations), null, 2);
+    }
+    return subgraphs
+        .map((s, at) => `${subgraphs.length > 1 ? `# result ${at + 1}\n` : ''}${render(s, format, options)}`)
+        .join('\n\n');
+}
+//# sourceMappingURL=present.js.map

package/dist/query.d.ts

@@ -0,0 +1,7 @@
+import type { SchemaQuery } from './schema/search.ts';
+export declare class QueryError extends Error {
+}
+export declare function parseQuery(value: unknown): SchemaQuery;
+/** Whether anything was actually asked, as opposed to only filtered. */
+export declare function isEmpty(query: SchemaQuery): boolean;
+//# sourceMappingURL=query.d.ts.map

package/dist/query.js

@@ -0,0 +1,88 @@
+// ---------------------------------------------------------------------------
+// A query, from somewhere untrusted
+//
+// `--query` and the tool both hand over a whole object, which means the shape
+// has to be checked rather than assumed. The rule is the same either way: a
+// key that is not known is an error, because a silently ignored
+// `output_propertys` looks exactly like a search that found nothing.
+// ---------------------------------------------------------------------------
+const LISTS = [
+    'all',
+    'methods',
+    'types',
+    'input_types',
+    'output_types',
+    'properties',
+    'input_properties',
+    'output_properties',
+    'exclude_ids',
+    'exclude_methods',
+    'exclude_types',
+    'exclude_properties',
+];
+const NUMBERS = ['limit', 'max_hops', 'max_nodes'];
+const DIRECTIONS = ['input', 'output', 'any'];
+const METHOD_TYPES = ['read_only', 'read_write', 'any'];
+const KNOWN = new Set([...LISTS, ...NUMBERS, 'direction', 'method_type']);
+export class QueryError extends Error {
+}
+export function parseQuery(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value)) {
+        throw new QueryError('a query must be an object');
+    }
+    const input = value;
+    for (const key of Object.keys(input)) {
+        if (!KNOWN.has(key)) {
+            throw new QueryError(`unknown query field "${key}" — expected ${[...KNOWN].join(', ')}`);
+        }
+    }
+    const out = {};
+    for (const key of LISTS) {
+        const list = input[key];
+        if (list === undefined) {
+            continue;
+        }
+        if (!Array.isArray(list) || list.some((v) => typeof v !== 'string')) {
+            throw new QueryError(`${key} must be an array of strings`);
+        }
+        out[key] = list;
+    }
+    for (const key of NUMBERS) {
+        const number = input[key];
+        if (number === undefined) {
+            continue;
+        }
+        if (typeof number !== 'number' || !Number.isInteger(number) || number < 1) {
+            throw new QueryError(`${key} must be a whole number of at least 1`);
+        }
+        out[key] = number;
+    }
+    if (input.direction !== undefined) {
+        out.direction = oneOf('direction', input.direction, DIRECTIONS);
+    }
+    if (input.method_type !== undefined) {
+        out.method_type = oneOf('method_type', input.method_type, METHOD_TYPES);
+    }
+    return out;
+}
+/** Whether anything was actually asked, as opposed to only filtered. */
+export function isEmpty(query) {
+    const terms = [
+        query.all,
+        query.methods,
+        query.types,
+        query.input_types,
+        query.output_types,
+        query.properties,
+        query.input_properties,
+        query.output_properties,
+    ];
+    return terms.every((list) => !list || list.length === 0);
+}
+function oneOf(key, value, allowed) {
+    if (typeof value !== 'string' || !allowed.includes(value)) {
+        throw new QueryError(`${key} must be one of ${allowed.join(', ')}`);
+    }
+    return value;
+}
+//# sourceMappingURL=query.js.map

package/dist/repl.d.ts

@@ -0,0 +1,8 @@
+import { type Format, type OutputOptions } from './present.ts';
+import type { SchemaIndex, SchemaQuery } from './schema/search.ts';
+interface Settings extends OutputOptions {
+    format: Format;
+}
+export declare function repl(index: SchemaIndex, initial: SchemaQuery, settings: Settings): Promise<void>;
+export {};
+//# sourceMappingURL=repl.d.ts.map

package/dist/repl.js

@@ -0,0 +1,119 @@
+import { createInterface } from 'node:readline/promises';
+import { bold, cyan, dim, note, write } from '@zenera/cli/lib';
+import { isFormat, present } from "./present.js";
+import { isEmpty, parseQuery, QueryError } from "./query.js";
+const FIELDS = {
+    all: 'all',
+    method: 'methods',
+    type: 'types',
+    'input-type': 'input_types',
+    'output-type': 'output_types',
+    property: 'properties',
+    'input-property': 'input_properties',
+    'output-property': 'output_properties',
+};
+export async function repl(index, initial, settings) {
+    const rl = createInterface({ input: process.stdin, output: process.stderr });
+    let query = { ...initial };
+    let format = settings.format;
+    const options = { docs: settings.docs, onlyHits: settings.onlyHits };
+    note(bold(`${index.manifest.sources.map((s) => s.title).join(', ')}`));
+    note(dim('  a bare line searches every kind; `help` lists the rest.'));
+    try {
+        if (!isEmpty(query)) {
+            query = await run(index, query, format, options);
+        }
+        for (;;) {
+            const line = (await rl.question(cyan('rag> '))).trim();
+            if (line === '') {
+                continue;
+            }
+            if (line === 'quit' || line === 'exit') {
+                return;
+            }
+            if (line === 'help') {
+                help();
+                continue;
+            }
+            if (line === 'reset') {
+                query = {};
+                note(dim('  cleared, exclusions and all'));
+                continue;
+            }
+            if (line === 'show') {
+                note(dim(`  ${JSON.stringify(query)}`));
+                continue;
+            }
+            const [head, ...rest] = line.split(' ');
+            const tail = rest.join(' ').trim();
+            if (head === 'format') {
+                if (isFormat(tail)) {
+                    format = tail;
+                    note(dim(`  format is ${tail}`));
+                }
+                else {
+                    note(dim('  expected text, mermaid, mermaid-flowchart, ts or openapi'));
+                }
+                continue;
+            }
+            if (head === 'direction' || head === 'method-type') {
+                query = patch(query, head === 'direction' ? 'direction' : 'method_type', tail);
+                continue;
+            }
+            if (head && head in FIELDS && tail) {
+                query = { ...query, [FIELDS[head]]: [tail] };
+                query = await run(index, query, format, options);
+                continue;
+            }
+            query = await run(index, { ...query, all: [line] }, format, options);
+        }
+    }
+    finally {
+        rl.close();
+    }
+}
+/**
+ * Runs the search, prints it, and hands back the query with everything just
+ * shown added to the exclusions — so asking the same thing twice moves on
+ * instead of repeating itself.
+ */
+async function run(index, query, format, options) {
+    const result = await index.search(query);
+    const text = await present(index, result.subgraphs, format, options);
+    if (text) {
+        write(text);
+    }
+    note(dim(`  ${result.seeds.length} seed(s) · ${result.subgraphs.length} result(s)` +
+        (result.empty.length > 0 ? ` · nothing for: ${result.empty.join(', ')}` : '')));
+    if (result.seeds.length === 0) {
+        return query;
+    }
+    const seen = new Set([...(query.exclude_ids ?? []), ...result.seeds.map((s) => s.id)]);
+    note(dim(`  ${seen.size} node(s) now excluded — \`reset\` to see them again`));
+    return { ...query, exclude_ids: [...seen] };
+}
+function patch(query, key, value) {
+    try {
+        return { ...query, ...parseQuery({ [key]: value }) };
+    }
+    catch (err) {
+        note(dim(`  ${err instanceof QueryError ? err.message : String(err)}`));
+        return query;
+    }
+}
+function help() {
+    for (const line of [
+        '  <text>                  search everything',
+        '  all|method|type <text>  search one field',
+        '  input-property <text>   also: output-property, property, input-type, output-type',
+        '  direction <d>           input | output | any',
+        '  method-type <t>         read_only | read_write | any',
+        '  format <f>              text | mermaid | mermaid-flowchart | ts | openapi',
+        '  show                    the query as it stands',
+        '  reset                   forget it, exclusions included',
+        '  quit',
+    ]) {
+        note(dim(line));
+    }
+}
+//# sourceMappingURL=repl.js.map

package/dist/schema/build.d.ts

@@ -0,0 +1,28 @@
+import type { Embedder } from '@zenera/neo';
+import { type EntityRecord } from './entities.ts';
+import { type Counts, type Manifest, type SourceRecord } from './files.ts';
+export interface BuildOptions {
+    files: readonly string[];
+    out: string;
+    embedder: Embedder;
+    /** the reference as it was written, which is what a later search will type */
+    embeddingRef?: string;
+    /** told the manifest, so a store can say what wrote it */
+    indexer: string;
+    /** texts sent to the embedder at once */
+    batch?: number;
+    signal?: AbortSignal;
+    /** what the documents turned out to hold, before a vector has been paid for */
+    onRead?: (summary: BuildSummary) => void;
+    onProgress?: (done: number, total: number) => void;
+}
+export interface BuildSummary {
+    sources: SourceRecord[];
+    counts: Counts;
+}
+export interface BuildResult {
+    manifest: Manifest;
+    entities: EntityRecord[];
+}
+export declare function buildIndex(options: BuildOptions): Promise<BuildResult>;
+//# sourceMappingURL=build.d.ts.map

package/dist/schema/build.js

@@ -0,0 +1,79 @@
+import { toEntities } from "./entities.js";
+import { INDEX_VERSION, writeIndex, } from "./files.js";
+import { buildGraph } from "./graph.js";
+import { loadSpecs } from "./spec.js";
+import { writeStore } from "./store.js";
+const DEFAULT_BATCH = 96;
+export async function buildIndex(options) {
+    const corpus = await loadSpecs(options.files);
+    const { graph, types } = buildGraph(corpus);
+    const entities = toEntities(graph);
+    const summary = {
+        sources: sourcesOf(corpus, entities, options.files),
+        counts: {
+            methods: entities.filter((e) => e.kind === 'method').length,
+            types: entities.filter((e) => e.kind === 'type').length,
+            properties: entities.filter((e) => e.kind === 'property').length,
+            entities: entities.length,
+        },
+    };
+    options.onRead?.(summary);
+    const vectors = await embedAll(entities, options);
+    const written = await writeStore(options.out, entities, vectors);
+    const manifest = {
+        version: INDEX_VERSION,
+        createdAt: new Date().toISOString(),
+        indexer: options.indexer,
+        embedding: {
+            ref: options.embeddingRef ?? options.embedder.id,
+            id: options.embedder.id,
+            dimensions: vectors[0]?.length ?? 0,
+        },
+        sources: summary.sources,
+        counts: summary.counts,
+        indexes: { fts: written.fts, vector: written.vector },
+    };
+    await writeIndex(options.out, { manifest, graph, types, operations: corpus.operations });
+    return { manifest, entities };
+}
+async function embedAll(entities, options) {
+    const size = options.batch ?? DEFAULT_BATCH;
+    const out = [];
+    for (let at = 0; at < entities.length; at += size) {
+        const slice = entities.slice(at, at + size);
+        const response = await options.embedder.embed({
+            input: slice.map((e) => e.text),
+            taskType: 'document',
+            signal: options.signal,
+        });
+        if (response.vectors.length !== slice.length) {
+            throw new Error(`${options.embedder.id} answered ${response.vectors.length} vectors for ${slice.length} texts`);
+        }
+        out.push(...response.vectors.map((v) => Float32Array.from(v)));
+        options.onProgress?.(out.length, entities.length);
+    }
+    return out;
+}
+/**
+ * Counted off the entities rather than the corpus, so a schema the document
+ * never named — an inline request body, say — is credited to the file it came
+ * from instead of going missing.
+ */
+function sourcesOf(corpus, entities, files) {
+    return corpus.docs.map((doc, index) => {
+        const mine = entities.filter((e) => e.source === doc.source);
+        const operations = corpus.operations.filter((op) => op.source === doc.source);
+        return {
+            path: files[index] ?? doc.source,
+            sha256: doc.sha256,
+            dialect: doc.dialect,
+            title: doc.title,
+            version: doc.version,
+            paths: new Set(operations.map((op) => op.path)).size,
+            methods: operations.length,
+            types: mine.filter((e) => e.kind === 'type').length,
+            properties: mine.filter((e) => e.kind === 'property').length,
+        };
+    });
+}
+//# sourceMappingURL=build.js.map

package/dist/schema/entities.d.ts

@@ -0,0 +1,18 @@
+import type { ApiGraph } from './graph.ts';
+export interface EntityRecord {
+    id: string;
+    kind: string;
+    name: string;
+    parent: string;
+    doc: string;
+    direction: string;
+    methodType: string;
+    httpMethod: string;
+    path: string;
+    source: string;
+    signature: string;
+    required: boolean;
+    text: string;
+}
+export declare function toEntities(graph: ApiGraph): EntityRecord[];
+//# sourceMappingURL=entities.d.ts.map

package/dist/schema/entities.js

@@ -0,0 +1,71 @@
+/** How many field names of a type are worth putting in its search text. */
+const FIELDS_IN_TEXT = 40;
+export function toEntities(graph) {
+    const out = [];
+    for (const id of graph.nodes()) {
+        const a = graph.getNodeAttributes(id);
+        out.push({
+            id,
+            kind: a.kind,
+            name: a.name,
+            parent: a.parent,
+            doc: a.doc,
+            direction: a.direction,
+            methodType: a.methodType,
+            httpMethod: a.httpMethod,
+            path: a.path,
+            source: a.source,
+            signature: a.signature,
+            required: a.required,
+            text: textOf(graph, id),
+        });
+    }
+    return out.sort((a, b) => a.id.localeCompare(b.id));
+}
+function textOf(graph, id) {
+    const a = graph.getNodeAttributes(id);
+    const parts = [];
+    if (a.kind === 'method') {
+        parts.push(`[method] ${a.httpMethod} ${a.path}`, a.name, a.methodType.replace('_', ' '));
+    }
+    else if (a.kind === 'type') {
+        parts.push(`[type] ${a.name}`, side(a.direction));
+        const fields = graph
+            .outEdges(id)
+            .filter((e) => graph.getEdgeAttribute(e, 'relation') === 'HAS_PROPERTY')
+            .slice(0, FIELDS_IN_TEXT)
+            .map((e) => graph.getNodeAttribute(graph.target(e), 'name'));
+        if (fields.length > 0) {
+            parts.push(`fields: ${fields.join(', ')}`);
+        }
+    }
+    else {
+        const where = a.parent ? ` in ${a.parent}` : '';
+        parts.push(`[property] ${a.name}${a.signature ? `: ${a.signature}` : ''}${where}`);
+        parts.push(side(a.direction));
+    }
+    const spaced = words(a.name);
+    if (spaced) {
+        parts.push(spaced);
+    }
+    if (a.doc) {
+        parts.push(`— ${a.doc}`);
+    }
+    return parts.filter(Boolean).join(' ').replace(/\s+/g, ' ').trim();
+}
+/**
+ * `meowVolume` as "meow volume". No tokenizer splits an identifier, so without
+ * this the only way to a field is to already know how it was capitalized.
+ */
+function words(name) {
+    const spaced = name
+        .replace(/([a-z0-9])([A-Z])/g, '$1 $2')
+        .replace(/[_\-.]+/g, ' ')
+        .toLowerCase()
+        .trim();
+    return spaced === name.toLowerCase() ? '' : spaced;
+}
+function side(direction) {
+    return direction === 'none' ? '' : `(${direction})`;
+}
+//# sourceMappingURL=entities.js.map

package/dist/schema/files.d.ts

@@ -0,0 +1,74 @@
+import type { ApiGraph } from './graph.ts';
+import type { Schema } from './schema.ts';
+import type { Operation } from './spec.ts';
+export declare const INDEX_VERSION = 1;
+export declare const MANIFEST_FILE = "manifest.json";
+export declare const GRAPH_FILE = "graph.json";
+export declare const SCHEMAS_FILE = "schemas.json";
+export declare const OPERATIONS_FILE = "operations.json";
+export declare const LANCE_DIR = "lance";
+export interface SourceRecord {
+    path: string;
+    sha256: string;
+    dialect: string;
+    title: string;
+    version: string;
+    paths: number;
+    methods: number;
+    types: number;
+    properties: number;
+}
+export interface Counts {
+    methods: number;
+    types: number;
+    properties: number;
+    entities: number;
+}
+export interface Manifest {
+    version: number;
+    createdAt: string;
+    indexer: string;
+    /** `ref` as it was typed, `id` as the embedder answers to it */
+    embedding: {
+        ref: string;
+        id: string;
+        dimensions: number;
+    };
+    sources: SourceRecord[];
+    counts: Counts;
+    /** whether the table carries an fts index, and whether it carries a vector one */
+    indexes: {
+        fts: boolean;
+        vector: boolean;
+    };
+}
+export interface WrittenIndex {
+    manifest: Manifest;
+    graph: ApiGraph;
+    types: Readonly<Record<string, Schema>>;
+    operations: readonly Operation[];
+}
+export interface OpenIndex {
+    dir: string;
+    manifest: Manifest;
+    graph: ApiGraph;
+    /** the raw schemas, read once and remembered */
+    schemas(): Promise<Record<string, Schema>>;
+    /** the operations, likewise */
+    operations(): Promise<Operation[]>;
+}
+export declare const lancePath: (dir: string) => string;
+export declare function writeIndex(dir: string, index: WrittenIndex): Promise<void>;
+export declare function openIndex(dir: string): Promise<OpenIndex>;
+export declare function readManifest(dir: string): Promise<Manifest>;
+/**
+ * A store answers with the neighbours of a vector, and a vector means nothing
+ * without the model that produced it. Asking one model's index a question
+ * embedded by another returns rows, in an order that is noise.
+ *
+ * Either spelling is accepted, because `openai:text-embedding-3-small` and
+ * `text-embedding-3-small` are one model and which of them was typed is not
+ * something anyone should have to remember.
+ */
+export declare function assertSameEmbedding(manifest: Manifest, ref: string): void;
+//# sourceMappingURL=files.d.ts.map

package/dist/schema/files.js

@@ -0,0 +1,79 @@
+import { MultiDirectedGraph } from 'graphology';
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { CliError, EXIT } from '@zenera/cli/lib';
+// ---------------------------------------------------------------------------
+// What an index is, on disk
+//
+// Four things in a directory, and the order they are written in is the whole
+// crash story: the manifest goes last, so a half-built index has no manifest
+// and reads as "not indexed" rather than as a store that quietly lost half its
+// operations.
+//
+// `graph.json` is deliberately thin — names, directions, edges — because it is
+// parsed whole on every search. The schemas are the bulk of the bytes and are
+// wanted only when something is being printed, so they live apart and are read
+// on first use.
+// ---------------------------------------------------------------------------
+export const INDEX_VERSION = 1;
+export const MANIFEST_FILE = 'manifest.json';
+export const GRAPH_FILE = 'graph.json';
+export const SCHEMAS_FILE = 'schemas.json';
+export const OPERATIONS_FILE = 'operations.json';
+export const LANCE_DIR = 'lance';
+export const lancePath = (dir) => join(dir, LANCE_DIR);
+export async function writeIndex(dir, index) {
+    await mkdir(dir, { recursive: true });
+    await writeFile(join(dir, GRAPH_FILE), JSON.stringify(index.graph.export()));
+    await writeFile(join(dir, SCHEMAS_FILE), JSON.stringify(index.types));
+    await writeFile(join(dir, OPERATIONS_FILE), JSON.stringify(index.operations));
+    await writeFile(join(dir, MANIFEST_FILE), `${JSON.stringify(index.manifest, null, 4)}\n`);
+}
+export async function openIndex(dir) {
+    const manifest = await readManifest(dir);
+    const graph = new MultiDirectedGraph();
+    graph.import(JSON.parse(await readFile(join(dir, GRAPH_FILE), 'utf8')));
+    return {
+        dir,
+        manifest,
+        graph,
+        schemas: once(() => read(dir, SCHEMAS_FILE)),
+        operations: once(() => read(dir, OPERATIONS_FILE)),
+    };
+}
+async function read(dir, file) {
+    return JSON.parse(await readFile(join(dir, file), 'utf8'));
+}
+function once(load) {
+    let pending;
+    return () => (pending ??= load());
+}
+export async function readManifest(dir) {
+    let text;
+    try {
+        text = await readFile(join(dir, MANIFEST_FILE), 'utf8');
+    }
+    catch {
+        throw new CliError(`${dir} does not hold an index`, EXIT.invalid, 'build one first with `zen rag schema index`');
+    }
+    const manifest = JSON.parse(text);
+    if (manifest.version !== INDEX_VERSION) {
+        throw new CliError(`${dir} was written by another version of this indexer`, EXIT.invalid, 'rebuild it with `zen rag schema index`');
+    }
+    return manifest;
+}
+/**
+ * A store answers with the neighbours of a vector, and a vector means nothing
+ * without the model that produced it. Asking one model's index a question
+ * embedded by another returns rows, in an order that is noise.
+ *
+ * Either spelling is accepted, because `openai:text-embedding-3-small` and
+ * `text-embedding-3-small` are one model and which of them was typed is not
+ * something anyone should have to remember.
+ */
+export function assertSameEmbedding(manifest, ref) {
+    if (ref !== manifest.embedding.ref && ref !== manifest.embedding.id) {
+        throw new CliError(`this index was built with ${manifest.embedding.ref}, not ${ref}`, EXIT.invalid, `search it with --embedding ${manifest.embedding.ref}, or rebuild it`);
+    }
+}
+//# sourceMappingURL=files.js.map

package/dist/schema/graph.d.ts

@@ -0,0 +1,48 @@
+import { MultiDirectedGraph } from 'graphology';
+import { type Schema } from './schema.ts';
+import { type Corpus, type MethodType, type ParamIn } from './spec.ts';
+export type NodeKind = 'method' | 'type' | 'property';
+export type Direction = 'input' | 'output' | 'both' | 'none';
+export type Relation = 'TAKES_INPUT' | 'HAS_PARAM' | 'RETURNS_OUTPUT' | 'HAS_PROPERTY' | 'OF_TYPE' | 'COMPOSES' | 'ITEM_OF';
+export interface NodeAttrs {
+    kind: NodeKind;
+    name: string;
+    /** owning type id for a property, operation id for a parameter, else '' */
+    parent: string;
+    doc: string;
+    direction: Direction;
+    methodType: MethodType | 'n/a';
+    httpMethod: string;
+    path: string;
+    source: string;
+    /** the TypeScript type expression, for properties */
+    signature: string;
+    required: boolean;
+}
+export interface EdgeAttrs {
+    relation: Relation;
+    /** on RETURNS_OUTPUT */
+    status: number;
+    /** on HAS_PARAM */
+    in: ParamIn | '';
+}
+export type ApiGraph = MultiDirectedGraph<NodeAttrs, EdgeAttrs>;
+export interface Built {
+    graph: ApiGraph;
+    /** every type the graph names, synthesized ones included */
+    types: Record<string, Schema>;
+}
+export declare const methodId: (operationId: string) => string;
+export declare const typeId: (name: string) => string;
+export declare const propertyId: (parent: string, name: string) => string;
+export declare const paramId: (operationId: string, name: string) => string;
+export declare function buildGraph(corpus: Corpus): Built;
+/**
+ * Which side of a call a node lives on. Seeded from the operations — a request
+ * body is an input, a response is an output — and then pushed down through
+ * composition until it stops. A DTO used both ways comes out `both`, which is
+ * the honest answer and the reason this is a closure rather than a flag set at
+ * the point of use.
+ */
+export declare function propagate(graph: ApiGraph): void;
+//# sourceMappingURL=graph.d.ts.map