attention-manifest-protocol 0.4.2 → 0.4.4

package/lib/hook/diff.js

@@ -0,0 +1,327 @@
+/**
+ * Line diff for the workspace hook layer.
+ *
+ * The implementation is a linear-space LCS (Hirschberg) rather than a full
+ * dynamic-programming matrix: two 5000-line inputs would otherwise allocate a
+ * 25M-cell table and a diff of two generated files could exhaust the worker.
+ * Hirschberg keeps only two `Int32Array` rows at a time and still reconstructs
+ * the actual match list, so hunks stay stable and ordered rather than merely
+ * reporting counts.
+ *
+ * The result is bounded by {@link DiffMaxLines}. A larger input is diffed on
+ * its first 5000 lines and reports `truncated: true`; the fingerprints always
+ * cover the whole input, so a truncated display is never mistaken for an
+ * unchanged file.
+ *
+ * Every hunk line carries both coordinates. `beforeLine` and `afterLine` are
+ * 1-based; on an added line `beforeLine` is the insertion point in the original
+ * file, and on a removed line `afterLine` is the insertion point in the new
+ * file. That makes it possible to render either side without re-counting.
+ */
+import { rawTextDigest } from "../fingerprint/raw.js";
+/**
+ * Maximum number of lines diffed per side. Beyond this the computation is
+ * bounded and the result says `truncated`.
+ */
+export const DiffMaxLines = 5000;
+/**
+ * Default number of unchanged lines kept on each side of a change.
+ */
+export const DiffDefaultContext = 3;
+/**
+ * Hard ceiling for a caller-supplied context size.
+ */
+export const DiffMaxContext = 20;
+/**
+ * Split text into logical lines. A trailing newline terminates the last line
+ * rather than creating an empty one; `\r` is stripped so CRLF files diff
+ * cleanly against LF content.
+ *
+ * @param text - Text to split.
+ * @returns Lines without terminators.
+ */
+export const splitDiffLines = (text) => {
+    if (text.length === 0) {
+        return [];
+    }
+    const lines = text.split("\n");
+    if (lines[lines.length - 1] === "") {
+        lines.pop();
+    }
+    return lines.map((line) => (line.endsWith("\r") ? line.slice(0, -1) : line));
+};
+/**
+ * Build a diff source from caller-supplied text. The fingerprint covers the
+ * exact input, including its trailing newline.
+ *
+ * @param text - Whole text.
+ * @returns Source lines, fingerprint and truncation flag.
+ */
+export const textDiffSource = (text) => ({
+    lines: splitDiffLines(text),
+    fingerprint: rawTextDigest(text),
+    truncated: false,
+});
+/**
+ * Forward LCS row for `a[aStart..aEnd)` against `b[bStart..bEnd)`.
+ *
+ * @returns Row where index `k` is the LCS length for the first `k` items of b.
+ */
+const lcsForward = (sides, aStart, aEnd, bStart, bEnd) => {
+    const a = sides.a;
+    const b = sides.b;
+    const width = bEnd - bStart;
+    let previous = new Int32Array(width + 1);
+    let current = new Int32Array(width + 1);
+    for (let index = aStart; index < aEnd; index += 1) {
+        current[0] = 0;
+        const left = a[index];
+        for (let column = 1; column <= width; column += 1) {
+            if (left === b[bStart + column - 1]) {
+                current[column] = previous[column - 1] + 1;
+            }
+            else {
+                current[column] = Math.max(previous[column], current[column - 1]);
+            }
+        }
+        const swap = previous;
+        previous = current;
+        current = swap;
+    }
+    return previous;
+};
+/**
+ * Backward LCS row. Index `k` is the LCS length of the suffix paired with the
+ * last `k` items of b, which is what makes a Hirschberg split possible.
+ */
+const lcsBackward = (sides, aStart, aEnd, bStart, bEnd) => {
+    const a = sides.a;
+    const b = sides.b;
+    const width = bEnd - bStart;
+    let previous = new Int32Array(width + 1);
+    let current = new Int32Array(width + 1);
+    for (let index = aEnd - 1; index >= aStart; index -= 1) {
+        current[0] = 0;
+        const left = a[index];
+        for (let column = 1; column <= width; column += 1) {
+            if (left === b[bEnd - column]) {
+                current[column] = previous[column - 1] + 1;
+            }
+            else {
+                current[column] = Math.max(previous[column], current[column - 1]);
+            }
+        }
+        const swap = previous;
+        previous = current;
+        current = swap;
+    }
+    return previous;
+};
+/**
+ * Collect the matched index pairs of one LCS in order.
+ *
+ * The recursion splits `a` in half, picks the `b` split that maximises the sum
+ * of the forward and backward LCS lengths, and recurses on both halves. Memory
+ * stays O(|b|) and the result is the same match list a full LCS table would
+ * produce.
+ *
+ * @param sides - Both line arrays.
+ * @param aStart - Inclusive start in `a`.
+ * @param aEnd - Exclusive end in `a`.
+ * @param bStart - Inclusive start in `b`.
+ * @param bEnd - Exclusive end in `b`.
+ * @param matchA - Output indices in `a`.
+ * @param matchB - Output indices in `b`.
+ */
+const collectMatches = (sides, aStart, aEnd, bStart, bEnd, matchA, matchB) => {
+    if (aStart >= aEnd || bStart >= bEnd) {
+        return;
+    }
+    const a = sides.a;
+    const b = sides.b;
+    if (aEnd - aStart === 1) {
+        for (let index = bStart; index < bEnd; index += 1) {
+            if (a[aStart] === b[index]) {
+                matchA.push(aStart);
+                matchB.push(index);
+                return;
+            }
+        }
+        return;
+    }
+    const middle = Math.floor((aStart + aEnd) / 2);
+    const forward = lcsForward(sides, aStart, middle, bStart, bEnd);
+    const backward = lcsBackward(sides, middle, aEnd, bStart, bEnd);
+    const width = bEnd - bStart;
+    let split = 0;
+    let best = -1;
+    for (let column = 0; column <= width; column += 1) {
+        const score = forward[column] + backward[width - column];
+        if (score > best) {
+            best = score;
+            split = column;
+        }
+    }
+    collectMatches(sides, aStart, middle, bStart, bStart + split, matchA, matchB);
+    collectMatches(sides, middle, aEnd, bStart + split, bEnd, matchA, matchB);
+};
+/**
+ * Turn two line arrays into an ordered operation list with 1-based counters.
+ *
+ * @param before - Original lines.
+ * @param after - New lines.
+ * @returns Diff lines in document order.
+ */
+const diffSequences = (before, after) => {
+    const matchA = [];
+    const matchB = [];
+    collectMatches({ a: before, b: after }, 0, before.length, 0, after.length, matchA, matchB);
+    const lines = [];
+    let beforeIndex = 0;
+    let afterIndex = 0;
+    let beforeLine = 1;
+    let afterLine = 1;
+    for (let index = 0; index < matchA.length; index += 1) {
+        const targetA = matchA[index];
+        const targetB = matchB[index];
+        while (beforeIndex < targetA) {
+            lines.push({ type: "remove", text: before[beforeIndex], beforeLine, afterLine });
+            beforeIndex += 1;
+            beforeLine += 1;
+        }
+        while (afterIndex < targetB) {
+            lines.push({ type: "add", text: after[afterIndex], beforeLine, afterLine });
+            afterIndex += 1;
+            afterLine += 1;
+        }
+        lines.push({ type: "context", text: before[beforeIndex], beforeLine, afterLine });
+        beforeIndex += 1;
+        afterIndex += 1;
+        beforeLine += 1;
+        afterLine += 1;
+    }
+    while (beforeIndex < before.length) {
+        lines.push({ type: "remove", text: before[beforeIndex], beforeLine, afterLine });
+        beforeIndex += 1;
+        beforeLine += 1;
+    }
+    while (afterIndex < after.length) {
+        lines.push({ type: "add", text: after[afterIndex], beforeLine, afterLine });
+        afterIndex += 1;
+        afterLine += 1;
+    }
+    return lines;
+};
+/**
+ * Group a flat operation list into hunks with at most `context` unchanged
+ * lines on either side. Two changes separated by at most `2 * context`
+ * unchanged lines share one hunk.
+ *
+ * @param lines - Flat diff lines.
+ * @param context - Unchanged lines retained on each side.
+ * @returns Hunks in document order.
+ */
+const buildHunks = (lines, context) => {
+    const changes = [];
+    for (let index = 0; index < lines.length; index += 1) {
+        if (lines[index].type !== "context") {
+            changes.push(index);
+        }
+    }
+    const hunks = [];
+    let index = 0;
+    while (index < changes.length) {
+        const start = Math.max(0, changes[index] - context);
+        let last = changes[index];
+        let next = index + 1;
+        while (next < changes.length && changes[next] - last <= context * 2 + 1) {
+            last = changes[next];
+            next += 1;
+        }
+        const end = Math.min(lines.length, last + context + 1);
+        const slice = lines.slice(start, end);
+        let beforeCount = 0;
+        let afterCount = 0;
+        for (let cursor = 0; cursor < slice.length; cursor += 1) {
+            if (slice[cursor].type !== "add") {
+                beforeCount += 1;
+            }
+            if (slice[cursor].type !== "remove") {
+                afterCount += 1;
+            }
+        }
+        hunks.push({
+            beforeStart: slice[0].beforeLine,
+            beforeLines: beforeCount,
+            afterStart: slice[0].afterLine,
+            afterLines: afterCount,
+            lines: slice,
+        });
+        index = next;
+    }
+    return hunks;
+};
+/**
+ * Clamp a context request into `[0, DiffMaxContext]`.
+ *
+ * @param value - Caller context, or `undefined` for the default.
+ * @returns Effective context size.
+ */
+const contextOf = (value) => {
+    if (value === (void 0) || !Number.isSafeInteger(value)) {
+        return DiffDefaultContext;
+    }
+    return Math.min(DiffMaxContext, Math.max(0, value));
+};
+/**
+ * Diff two prepared sources. The fingerprints on the result always cover the
+ * whole input, even when the diff was truncated to `DiffMaxLines`.
+ *
+ * @param path - Root-relative path the result describes.
+ * @param before - Original side.
+ * @param after - New side.
+ * @param context - Unchanged lines retained on each side.
+ * @returns Diff result with counts and hunks.
+ */
+export const diffSources = (path, before, after, context = DiffDefaultContext) => {
+    const boundedContext = contextOf(context);
+    const beforeTruncated = before.lines.length > DiffMaxLines;
+    const afterTruncated = after.lines.length > DiffMaxLines;
+    const beforeLines = beforeTruncated ? before.lines.slice(0, DiffMaxLines) : before.lines;
+    const afterLines = afterTruncated ? after.lines.slice(0, DiffMaxLines) : after.lines;
+    const lines = diffSequences(beforeLines, afterLines);
+    let added = 0;
+    let removed = 0;
+    let unchanged = 0;
+    for (let index = 0; index < lines.length; index += 1) {
+        if (lines[index].type === "add") {
+            added += 1;
+        }
+        else if (lines[index].type === "remove") {
+            removed += 1;
+        }
+        else {
+            unchanged += 1;
+        }
+    }
+    return {
+        path,
+        beforeFingerprint: before.fingerprint,
+        afterFingerprint: after.fingerprint,
+        added,
+        removed,
+        unchanged,
+        hunks: buildHunks(lines, boundedContext),
+        truncated: before.truncated || after.truncated || beforeTruncated || afterTruncated,
+    };
+};
+/**
+ * Diff two texts directly.
+ *
+ * @param path - Root-relative path the result describes.
+ * @param before - Original text.
+ * @param after - New text.
+ * @param options - Context size.
+ * @returns Diff result.
+ */
+export const diffText = (path, before, after, options = {}) => diffSources(path, textDiffSource(before), textDiffSource(after), options.context);

package/lib/hook/exportation.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Export hooks.
+ *
+ * `useParse` is the cheap read helper; `useExportation` is the observable hook.
+ * Both call `FilesystemSession.exports`, so re-export edges, signatures and the
+ * fingerprint come from the one extractor the service already uses.
+ */
+import type { ExportRequest } from "../file/service.js";
+import type { ExportReport } from "../file/types.js";
+import type { Hook, HookOptions, HookSession } from "./types.js";
+/**
+ * Parse helper shape: one path in, one export report out.
+ */
+export type ExportationParse = (path: string) => ExportReport;
+/**
+ * Read the export report for one path. Re-exports are included because a
+ * module's public surface is incomplete without them.
+ *
+ * @param session - Bound filesystem session.
+ * @returns Parse helper.
+ */
+export declare const useParse: (session: HookSession) => ExportationParse;
+/**
+ * Exportation hook. `includeReexports` is forwarded unchanged, so a caller can
+ * ask for the narrow symbol list or the complete surface.
+ *
+ * @param session - Bound filesystem session.
+ * @param options - Recorder and cache options.
+ * @returns Hook producing one export report.
+ */
+export declare const useExportation: (session: HookSession, options?: HookOptions) => Hook<ExportRequest, ExportReport>;

package/lib/hook/exportation.js

@@ -0,0 +1,24 @@
+import { createHook } from "./types.js";
+/**
+ * Read the export report for one path. Re-exports are included because a
+ * module's public surface is incomplete without them.
+ *
+ * @param session - Bound filesystem session.
+ * @returns Parse helper.
+ */
+export const useParse = (session) => (path) => session.exports({ path, includeReexports: true });
+/**
+ * Exportation hook. `includeReexports` is forwarded unchanged, so a caller can
+ * ask for the narrow symbol list or the complete surface.
+ *
+ * @param session - Bound filesystem session.
+ * @param options - Recorder and cache options.
+ * @returns Hook producing one export report.
+ */
+export const useExportation = (session, options = {}) => createHook({
+    name: "exportation",
+    session,
+    execute: (request) => session.exports(request),
+    pathOf: (request) => request.path,
+    options,
+});

package/lib/hook/file.d.ts

@@ -0,0 +1,44 @@
+import type { ReadPage, ReadRequest, WriteRequest, WriteResult } from "../file/types.js";
+import type { DiffRequest, DiffResult } from "./diff.js";
+import type { Hook, HookOptions, HookSession } from "./types.js";
+/**
+ * Read hook. Delegates one `ReadRequest` to the session and keeps `bigint`
+ * totals (`totalLines`/`totalBytes`) intact; the hook layer never projects a
+ * domain value onto JSON.
+ *
+ * Caching is opt-in through `options.cache`. The cache key covers the request
+ * only, so a host that enables it after a write should reset the hook or create
+ * a new one; the default is uncached because a stale read is worse than a
+ * repeated one.
+ *
+ * @param session - Bound filesystem session.
+ * @param options - Recorder and cache options.
+ * @returns Hook producing one bounded read page.
+ */
+export declare const useRead: (session: HookSession, options?: HookOptions) => Hook<ReadRequest, ReadPage>;
+/**
+ * Write hook. This is the only mutable operation in the hook layer.
+ *
+ * The success revision is `WriteResult.revision`, the revision the write
+ * actually produced, rather than a later session read that could include an
+ * unrelated change. The cache is always disabled.
+ *
+ * @param session - Bound filesystem session.
+ * @param options - Recorder options; `cache` is ignored.
+ * @returns Hook producing one write result.
+ */
+export declare const useWrite: (session: HookSession, options?: HookOptions) => Hook<WriteRequest, WriteResult>;
+/**
+ * Diff hook.
+ *
+ * `request.before` overrides the old side and `request.content` overrides the
+ * new side; an omitted side is read from the session. With both omitted the
+ * file is read once and compared with itself, which reports no hunks. The
+ * request cache is disabled because the result depends on the file on disk,
+ * not only on the request.
+ *
+ * @param session - Bound filesystem session.
+ * @param options - Recorder options; `cache` is ignored.
+ * @returns Hook producing one bounded diff.
+ */
+export declare const useDiff: (session: HookSession, options?: HookOptions) => Hook<DiffRequest, DiffResult>;

package/lib/hook/file.js

@@ -0,0 +1,154 @@
+/**
+ * File hooks: read, write and diff.
+ *
+ * `useWrite` is the only mutating hook in the whole layer. It forwards one
+ * `WriteRequest` to the bound `FilesystemSession.write` and reports the
+ * post-write revision from the result; it never enables the request cache,
+ * because replaying a write from cache would silently skip the second write
+ * and turn a "create" into a success that never touched the disk.
+ *
+ * `useRead` and `useDiff` are read-only. `useDiff` reconstructs the current file
+ * page by page (the read contract caps one page at 2000 lines and 256 KiB) and
+ * treats a missing file as the empty string, so "new file" and "deleted file"
+ * are both expressible without a special request shape.
+ */
+import { isFilesystemError } from "../file/errors.js";
+import { rawTextDigest } from "../fingerprint/raw.js";
+import { DiffMaxLines, diffSources, textDiffSource } from "./diff.js";
+import { createHook } from "./types.js";
+/**
+ * Largest page the read contract returns, in lines.
+ */
+const ReadPageLines = 2000;
+/**
+ * Largest page the read contract returns, in UTF-8 bytes.
+ */
+const ReadPageBytes = 256 * 1024;
+/**
+ * Read a whole file as diff lines. A missing file is the empty side; every
+ * other classified failure propagates. The fingerprint comes from the first
+ * page, which already covers the entire file bytes.
+ *
+ * Page text is returned without a trailing newline, so a page that ends on a
+ * blank line would lose that line if it were split naively. The page's
+ * inclusive `startLine`/`endLine` range is authoritative; missing trailing
+ * blanks are restored so a multi-page diff keeps every line.
+ */
+const readDiffSource = (session, path) => {
+    const lines = [];
+    let startLine = 1;
+    let fingerprint = rawTextDigest("");
+    let truncated = false;
+    let first = true;
+    while (lines.length <= DiffMaxLines) {
+        let page;
+        try {
+            page = session.read({
+                path,
+                startLine,
+                maxLines: Math.min(ReadPageLines, DiffMaxLines + 1 - lines.length),
+                maxBytes: ReadPageBytes,
+            });
+        }
+        catch (error) {
+            if (isFilesystemError(error) && error.code === "not_found") {
+                return { lines: [], fingerprint: rawTextDigest(""), truncated: false };
+            }
+            throw error;
+        }
+        if (first) {
+            fingerprint = page.fingerprint;
+            first = false;
+        }
+        const expected = page.endLine - page.startLine + 1;
+        if (expected > 0) {
+            const pageLines = page.text.length === 0 ? [] : page.text.split("\n").map((line) => (line.endsWith("\r") ? line.slice(0, -1) : line));
+            for (let index = 0; index < pageLines.length; index += 1) {
+                lines.push(pageLines[index]);
+            }
+            while (pageLines.length < expected) {
+                lines.push("");
+                pageLines.push("");
+            }
+        }
+        if (page.nextStartLine === null) {
+            break;
+        }
+        if (page.nextStartLine <= startLine) {
+            truncated = true;
+            break;
+        }
+        startLine = page.nextStartLine;
+    }
+    if (lines.length > DiffMaxLines) {
+        lines.length = DiffMaxLines;
+        truncated = true;
+    }
+    return { lines, fingerprint, truncated };
+};
+/**
+ * Read hook. Delegates one `ReadRequest` to the session and keeps `bigint`
+ * totals (`totalLines`/`totalBytes`) intact; the hook layer never projects a
+ * domain value onto JSON.
+ *
+ * Caching is opt-in through `options.cache`. The cache key covers the request
+ * only, so a host that enables it after a write should reset the hook or create
+ * a new one; the default is uncached because a stale read is worse than a
+ * repeated one.
+ *
+ * @param session - Bound filesystem session.
+ * @param options - Recorder and cache options.
+ * @returns Hook producing one bounded read page.
+ */
+export const useRead = (session, options = {}) => createHook({
+    name: "read",
+    session,
+    execute: (request) => session.read(request),
+    pathOf: (request) => request.path,
+    options,
+});
+/**
+ * Write hook. This is the only mutable operation in the hook layer.
+ *
+ * The success revision is `WriteResult.revision`, the revision the write
+ * actually produced, rather than a later session read that could include an
+ * unrelated change. The cache is always disabled.
+ *
+ * @param session - Bound filesystem session.
+ * @param options - Recorder options; `cache` is ignored.
+ * @returns Hook producing one write result.
+ */
+export const useWrite = (session, options = {}) => createHook({
+    name: "write",
+    session,
+    execute: (request) => session.write(request),
+    pathOf: (request) => request.path,
+    revisionOf: (result) => result.revision,
+    options: { ...options, cache: false },
+});
+/**
+ * Diff hook.
+ *
+ * `request.before` overrides the old side and `request.content` overrides the
+ * new side; an omitted side is read from the session. With both omitted the
+ * file is read once and compared with itself, which reports no hunks. The
+ * request cache is disabled because the result depends on the file on disk,
+ * not only on the request.
+ *
+ * @param session - Bound filesystem session.
+ * @param options - Recorder options; `cache` is ignored.
+ * @returns Hook producing one bounded diff.
+ */
+export const useDiff = (session, options = {}) => createHook({
+    name: "diff",
+    session,
+    execute: (request) => {
+        const beforeText = request.before;
+        const afterText = request.content;
+        const before = beforeText === (void 0) ? readDiffSource(session, request.path) : textDiffSource(beforeText);
+        const after = afterText === (void 0) ? (beforeText === (void 0) ? before : readDiffSource(session, request.path)) : textDiffSource(afterText);
+        return diffSources(request.path, before, after, request.context);
+    },
+    pathOf: (request) => request.path,
+    options: { ...options, cache: false },
+});

package/lib/hook/importation.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Import hooks.
+ *
+ * `useParse` reports the outgoing imports of one file; `useImportation` wraps
+ * the same session call as an observable hook and forwards `direction`,
+ * `depth`, `includeExternal` and `limit` unchanged.
+ *
+ * Incoming edges are expensive because they require the root graph. The parse
+ * helper therefore keeps the service default (`outgoing`); a caller that wants
+ * `importedBy` asks for `direction: "incoming"` or `"both"` explicitly.
+ */
+import type { ImportRequest } from "../file/service.js";
+import type { ImportReport } from "../file/types.js";
+import type { Hook, HookOptions, HookSession } from "./types.js";
+/**
+ * Parse helper shape: one path in, one import report out.
+ */
+export type ImportationParse = (path: string) => ImportReport;
+/**
+ * Read the outgoing import report for one path.
+ *
+ * @param session - Bound filesystem session.
+ * @returns Parse helper.
+ */
+export declare const useParse: (session: HookSession) => ImportationParse;
+/**
+ * Importation hook.
+ *
+ * @param session - Bound filesystem session.
+ * @param options - Recorder and cache options.
+ * @returns Hook producing one import report.
+ */
+export declare const useImportation: (session: HookSession, options?: HookOptions) => Hook<ImportRequest, ImportReport>;

package/lib/hook/importation.js

@@ -0,0 +1,22 @@
+import { createHook } from "./types.js";
+/**
+ * Read the outgoing import report for one path.
+ *
+ * @param session - Bound filesystem session.
+ * @returns Parse helper.
+ */
+export const useParse = (session) => (path) => session.imports({ path });
+/**
+ * Importation hook.
+ *
+ * @param session - Bound filesystem session.
+ * @param options - Recorder and cache options.
+ * @returns Hook producing one import report.
+ */
+export const useImportation = (session, options = {}) => createHook({
+    name: "importation",
+    session,
+    execute: (request) => session.imports(request),
+    pathOf: (request) => request.path,
+    options,
+});

package/lib/hook/index.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Public surface of the hook layer.
+ *
+ * The concrete `use*` hooks and their shared types are exported here. Each
+ * module has its own `useParse` read helper, so those collide by design; they
+ * are re-exported under module-qualified names (`useCodeParse`,
+ * `useProjectParse`, ...) and the original name remains available from the
+ * module itself.
+ *
+ * `createHook` is re-exported explicitly because it is the extension point a
+ * host uses to add a hook without changing this package.
+ */
+export * from "./types.js";
+export * from "./diff.js";
+export * from "./file.js";
+export { createHook } from "./types.js";
+export type { DependencyFacts, DependencyParse } from "./dependency.js";
+export { useDependency, useParse as useDependencyParse } from "./dependency.js";
+export type { ExportationParse } from "./exportation.js";
+export { useExportation, useParse as useExportationParse } from "./exportation.js";
+export type { ImportationParse } from "./importation.js";
+export { useImportation, useParse as useImportationParse } from "./importation.js";
+export type { OutlineParse } from "./outline.js";
+export { useOutline, useParse as useOutlineParse } from "./outline.js";
+export type { AstParse } from "./ast.js";
+export { useAst, useParse as useAstParse } from "./ast.js";
+export type { CodeModel, CodeParse, CodeRequest } from "./code.js";
+export { useCode, useParse as useCodeParse } from "./code.js";
+export type { ProjectKind, ProjectModel, ProjectParse, ProjectRequest } from "./project.js";
+export { projectKindOf, useProject, useParse as useProjectParse } from "./project.js";