waygraph 0.15.53 → 0.16.0

package/dist/{session → live/pilot}/pilot.d.ts

@@ -28,9 +28,10 @@
  * hand-picking indices from each status response) that proved this needs no
  * new execution primitive.
  */
-import { type WaygraphGraph } from "../analysis/graph.js";
-import { type BrowserStartInit } from "./browser.js";
-import type { SessionSnapshot } from "../auto-session.js";
+import { type WaygraphGraph } from "../../analysis/graph.js";
+import { type BrowserStartInit } from "../auto-session/start.js";
+import type { SessionSnapshot } from "../auto-session/helpers.js";
+/** What `pilotStart` returns: the session id, socket path and first snapshot. */
 export interface PilotStartResult {
     sessionId: string;
     socketPath: string;

package/dist/{session → live/pilot}/pilot.js

@@ -28,9 +28,9 @@
  * hand-picking indices from each status response) that proved this needs no
  * new execution primitive.
  */
-import { discoverGraph } from "../analysis/graph.js";
-import { requestSession, resolveSessionMeta, } from "./auto-session-ipc.js";
-import { browserStart } from "./browser.js";
+import { discoverGraph } from "../../analysis/graph.js";
+import { requestSession, resolveSessionMeta, } from "../auto-session/ipc.js";
+import { browserStart } from "../auto-session/start.js";
 /**
  * Starts a detached session and reads back its own graph + starting
  * snapshot in one call, so an agent bootstraps with everything it needs
@@ -39,7 +39,7 @@ import { browserStart } from "./browser.js";
  * --detach` and `waygraph graph` itself.
  */
 export async function pilotStart(init) {
-    const { resolveInjectRoots } = await import("./block-inject.js");
+    const { resolveInjectRoots } = await import("../../manifest/roots.js");
     const exploreInject = init.inject ??
         (init.injectTokens?.length ? resolveInjectRoots(init.injectTokens, init.projectDir) : undefined);
     const started = await browserStart({

package/dist/{traverse → live/traverse}/coverage.d.ts

@@ -1,3 +1,4 @@
+/** The edge-coverage report `traverse` writes: which graph edges were walked. */
 export interface TraverseCoverageReport {
     version: 1;
     generatedAt: string;
@@ -41,6 +42,7 @@ export declare function normalizeHitKey(hitKey: string, graphKeys: ReadonlySet<s
  * Returns 0-1 fraction, or null when unset/invalid.
  */
 export declare function parseMinEdgeCoverage(raw: unknown): number | null;
+/** Builds the `traverse` coverage report from the edges walked and the graph's edges. */
 export declare function buildCoverageReport(opts: {
     projectDir: string;
     parallel: number;
@@ -51,5 +53,7 @@ export declare function buildCoverageReport(opts: {
 }): TraverseCoverageReport;
 /** Greppable one-liner for agents/CI. */
 export declare function formatCoverageLine(report: TraverseCoverageReport): string;
+/** Where `traverse` writes its coverage report by default. */
 export declare function defaultCoverageOutPath(projectDir: string): string;
+/** Writes the `traverse` coverage report to disk. */
 export declare function writeCoverageReport(path: string, report: TraverseCoverageReport): void;

package/dist/{traverse → live/traverse}/coverage.js

@@ -68,6 +68,7 @@ export function parseMinEdgeCoverage(raw) {
         return n / 100;
     return null;
 }
+/** Builds the `traverse` coverage report from the edges walked and the graph's edges. */
 export function buildCoverageReport(opts) {
     const all = [...new Set(opts.allEdgeKeys)].sort();
     const graphSet = new Set(all);
@@ -118,9 +119,11 @@ export function formatCoverageLine(report) {
         : "";
     return `[Coverage edges=${report.edgesHit}/${report.edgesTotal} ratio=${pct}%${minPart}]`;
 }
+/** Where `traverse` writes its coverage report by default. */
 export function defaultCoverageOutPath(projectDir) {
     return join(projectDir, ".waygraph-traverse", "coverage.json");
 }
+/** Writes the `traverse` coverage report to disk. */
 export function writeCoverageReport(path, report) {
     mkdirSync(dirname(path), { recursive: true });
     writeFileSync(path, JSON.stringify(report, null, 2) + "\n", "utf-8");

package/dist/{traverse → live/traverse}/lease.d.ts

@@ -2,6 +2,7 @@ export interface EdgeLeaseRecord {
     workerId: string;
     claimedAt: number;
 }
+/** Hands out graph edges to parallel `traverse` workers so no two workers walk the same edge. */
 export declare class EdgeLeaseCoordinator {
     private readonly held;
     private readonly dir;

package/dist/{traverse → live/traverse}/lease.js

@@ -5,6 +5,7 @@
  */
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+/** Hands out graph edges to parallel `traverse` workers so no two workers walk the same edge. */
 export class EdgeLeaseCoordinator {
     held = new Map();
     dir;

package/dist/{traverse/run.d.ts → live/traverse/traverse.d.ts}

@@ -1,10 +1,13 @@
+/** How `traverse` workers share a browser: one session, or a clone per worker. */
 export type TraverseSessionMode = "clone" | "inherit";
+/** What one `traverse` worker did: edges walked and failures. */
 export interface TraverseWorkerResult {
     exitCode: number;
     steps: number;
     edgesHit: string[];
     leaf?: string;
 }
+/** Options for `runTraverse`: workers, session mode, step limit, coverage gate. */
 export interface TraverseOptions {
     baseURL?: string;
     startUrl?: string;
@@ -25,7 +28,7 @@ export interface TraverseOptions {
     /** Traverse id for greppable lines (default traverse-1). */
     traverseId?: string;
     /** Phase C: glob / regex / bare `--blocks` file select. */
-    blocksSelect?: import("../blocks-select.js").BlocksSelect;
+    blocksSelect?: import("../../manifest/select.js").BlocksSelect;
     /** Phase D: parallel workers (default 1). Cap 4. */
     parallel?: number;
     /** Phase D: clone (default) or inherit. Inherit refused when parallel > 1. */

package/dist/{traverse/run.js → live/traverse/traverse.js}

@@ -1,13 +1,16 @@
-import { Engine, start, end, locate } from "../core.js";
-import { MemPage } from "../mem-page.js";
-import { buildExploreContext, buildExploreMenu, } from "../session/auto-explore.js";
-import { defaultMemValueForKey } from "../session/auto-explore-run.js";
-import { resolveBaseUrl } from "../config.js";
+import { Engine } from "../../engine/engine.js";
+import { buildFlow } from "../../engine/flow/flow.js";
+import { MemPage } from "../../engine/mem/mem.js";
+import { buildExploreContext, buildExploreMenu, } from "../auto/explore.js";
+import { detectHere, memStubValue } from "../auto/auto.js";
+import { resolveBaseUrl } from "../../runtime/waygraph-config.js";
 import { EdgeLeaseCoordinator } from "./lease.js";
 import { buildCoverageReport, collectGraphEdgeKeys, defaultCoverageOutPath, formatCoverageLine, writeCoverageReport, } from "./coverage.js";
-import { chromiumExecutablePath } from "../browser.js";
+import { chromiumExecutablePath } from "../../runtime/browser.js";
+import { envFlag, envString } from "../../engine/env.js";
+import { ignorePageGone, ignoreTimeout } from "../../engine/page-gone.js";
 function seedMem(library, mem, dataJson) {
-    const raw = dataJson ?? process.env.WAYGRAPH_DATA ?? process.env.WAYGRAPH_AUTO_MEM;
+    const raw = dataJson ?? envString("WAYGRAPH_DATA") ?? envString("WAYGRAPH_AUTO_MEM");
     let envParsed = {};
     if (raw) {
         try {
@@ -25,7 +28,7 @@ function seedMem(library, mem, dataJson) {
                 mem.set(k, envParsed[k.name]);
                 continue;
             }
-            const def = defaultMemValueForKey(k.name);
+            const def = memStubValue(k);
             if (def !== undefined)
                 mem.set(k, def);
         }
@@ -36,12 +39,7 @@ function snapshotMem(library, mem) {
     for (const entry of library.values()) {
         for (const k of entry.block.requires ?? []) {
             if (mem.has(k) && !(k.name in out)) {
-                try {
-                    out[k.name] = mem.get(k);
-                }
-                catch {
-                    /* skip */
-                }
+                out[k.name] = mem.get(k);
             }
         }
     }
@@ -71,23 +69,8 @@ function edgeKey(edge) {
     const id = edge.instanceOption?.id;
     return id ? `${edge.block}::${id}` : edge.block;
 }
-async function detectHere(page, navBlocks) {
-    try {
-        const url = page.url();
-        if (url.includes("/login"))
-            return "PiaLogin";
-        if (url.includes("mailpit") || url.includes(":54324") || url.includes("/mailhog")) {
-            return "PiaMailpitGui";
-        }
-    }
-    catch {
-        /* ignore */
-    }
-    const tags = navBlocks.map((n) => n.block);
-    return locate(page, tags, { timeoutMs: 1500 });
-}
 async function runOneBlock(engine, entry, context, page, mem) {
-    const flow = engine.defineFlow([start, entry.block, end]);
+    const flow = buildFlow([entry.block], engine.config);
     const BLOCK_TIMEOUT_MS = 45_000;
     let timer;
     try {
@@ -131,7 +114,7 @@ async function runTraverseWorker(opts) {
             if (page.isClosed()) {
                 page = await context.newPage();
                 if (startUrl) {
-                    await page.goto(startUrl, { waitUntil: "domcontentloaded" }).catch(() => { });
+                    await page.goto(startUrl, { waitUntil: "domcontentloaded" }).catch(ignorePageGone);
                 }
             }
             const detected = await detectHere(page, library.navBlocks);
@@ -238,8 +221,8 @@ export async function runTraverse(projectDir, options = {}) {
     const maxVisitsPerNode = options.maxVisitsPerNode ?? 2;
     const maxVisitsPerEdge = options.maxVisitsPerEdge ?? 1;
     const timeoutMs = options.timeoutMs ?? 15 * 60_000;
-    const headed = options.headed === true || process.env.WAYGRAPH_HEADED === "1";
-    const baseURL = options.baseURL ?? (await resolveBaseUrl(projectDir)) ?? process.env.WAYGRAPH_BASE_URL;
+    const headed = options.headed === true || envFlag("WAYGRAPH_HEADED");
+    const baseURL = options.baseURL ?? (await resolveBaseUrl(projectDir)) ?? envString("WAYGRAPH_BASE_URL");
     const startUrl = options.startUrl ?? baseURL;
     const minEdgeCoverage = options.minEdgeCoverage != null && Number.isFinite(options.minEdgeCoverage)
         ? options.minEdgeCoverage
@@ -253,7 +236,7 @@ export async function runTraverse(projectDir, options = {}) {
     const allEdgeKeys = collectGraphEdgeKeys(graph.edges);
     const leases = new EdgeLeaseCoordinator({ projectDir, persist: parallel > 1 });
     const engine = new Engine({ headless: !headed, slowMo: headed ? 100 : 0 });
-    if (process.env.WAYGRAPH_EXTENSIONS)
+    if (envString("WAYGRAPH_EXTENSIONS"))
         console.error("waygraph traverse: extensions are not loaded (workers use plain contexts)");
     const { chromium } = await import("@playwright/test");
     const executablePath = chromiumExecutablePath();
@@ -318,8 +301,8 @@ export async function runTraverse(projectDir, options = {}) {
             const mem = new MemPage();
             seedMem(library.byName, mem, options.data);
             if (startUrl) {
-                await page.goto(startUrl, { waitUntil: "domcontentloaded" }).catch(() => { });
-                await page.waitForLoadState("load").catch(() => { });
+                await page.goto(startUrl, { waitUntil: "domcontentloaded" }).catch(ignorePageGone);
+                await page.waitForLoadState("load").catch(ignoreTimeout);
             }
             const traverseId = options.traverseId ?? "traverse-1";
             const result = await runTraverseWorker({
@@ -342,7 +325,7 @@ export async function runTraverse(projectDir, options = {}) {
                 mem,
                 leases,
             });
-            await context.close().catch(() => { });
+            await context.close().catch(ignorePageGone);
             const coverageCode = emitCoverage([{ traverseId, result }]);
             if (result.exitCode !== 0)
                 return result.exitCode;
@@ -359,12 +342,12 @@ export async function runTraverse(projectDir, options = {}) {
         const bootMem = new MemPage();
         seedMem(library.byName, bootMem, options.data);
         if (startUrl) {
-            await bootPage.goto(startUrl, { waitUntil: "domcontentloaded" }).catch(() => { });
-            await bootPage.waitForLoadState("load").catch(() => { });
+            await bootPage.goto(startUrl, { waitUntil: "domcontentloaded" }).catch(ignorePageGone);
+            await bootPage.waitForLoadState("load").catch(ignoreTimeout);
         }
         const storageState = await bootContext.storageState();
         const memSnap = snapshotMem(library.byName, bootMem);
-        await bootContext.close().catch(() => { });
+        await bootContext.close().catch(ignorePageGone);
         console.error(`waygraph traverse: forked ${parallel} clone workers (storageState + mem snapshot)`);
         const workerMeta = await Promise.all(Array.from({ length: parallel }, async (_, i) => {
             const traverseId = `traverse-${i + 1}`;
@@ -379,7 +362,7 @@ export async function runTraverse(projectDir, options = {}) {
             const mem = new MemPage();
             restoreMem(library.byName, mem, memSnap, options.data);
             if (startUrl) {
-                await page.goto(startUrl, { waitUntil: "domcontentloaded" }).catch(() => { });
+                await page.goto(startUrl, { waitUntil: "domcontentloaded" }).catch(ignorePageGone);
             }
             try {
                 const result = await runTraverseWorker({
@@ -405,7 +388,7 @@ export async function runTraverse(projectDir, options = {}) {
                 return { traverseId, result };
             }
             finally {
-                await context.close().catch(() => { });
+                await context.close().catch(ignorePageGone);
             }
         }));
         const results = workerMeta.map((w) => w.result);
@@ -418,6 +401,6 @@ export async function runTraverse(projectDir, options = {}) {
         return coverageCode;
     }
     finally {
-        await browser.close().catch(() => { });
+        await browser.close().catch(ignorePageGone);
     }
 }

package/dist/manifest/manifest.d.ts

@@ -0,0 +1,52 @@
+import type { BlockKind, ProjectScan, ScanOptions } from "./project.js";
+export declare const MANIFEST_VERSION = 1;
+export interface ManifestBlock {
+    /** `file#exportName`, unique across the project. */
+    id: string;
+    name: string;
+    exportName: string;
+    kind: BlockKind;
+    description: string;
+    from: string[];
+    to: string[];
+    requires: string[];
+    file: string;
+    /** The `src/map/` group folder the Block lives in (e.g. `(external)/hoppscotch`), or the map package it came from. */
+    map?: string;
+}
+export interface ManifestFlow {
+    /** `file#exportName`. */
+    id: string;
+    exportName: string;
+    file: string;
+    /** The folders under `src/flows/` (the page or `(user-story)` it belongs to) and the file's name (the outcome). */
+    useCase: {
+        path: string[];
+        outcome: string;
+    };
+    /** Block names in run order, nested flows flattened. */
+    steps: string[];
+    settings: {
+        memStub?: true;
+        expectedFailure?: string;
+        sessionReset?: true;
+        demoPace?: unknown;
+    };
+}
+export interface Manifest {
+    version: number;
+    project: {
+        name: string;
+        dir: string;
+        waygraph: string;
+    };
+    checkpoints: string[];
+    maps: string[];
+    blocks: ManifestBlock[];
+    flows: ManifestFlow[];
+    skipped: ProjectScan["skipped"];
+}
+/** Builds the manifest from a scan. */
+export declare function manifestFromScan(scan: ProjectScan): Manifest;
+/** Scans the project and returns its manifest. */
+export declare function buildManifest(projectDir: string, opts?: ScanOptions): Promise<Manifest>;

package/dist/manifest/manifest.js

@@ -0,0 +1,93 @@
+// The manifest: everything a project defines, as plain JSON. `waygraph manifest` prints it; Waygraph UI and map packages
+// read it instead of importing the project.
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { scanProject } from "./project.js";
+export const MANIFEST_VERSION = 1;
+function packageVersion() {
+    try {
+        return JSON.parse(readFileSync(join(dirname(new URL(import.meta.url).pathname), "..", "..", "package.json"), "utf8")).version;
+    }
+    catch {
+        return "unknown";
+    }
+}
+function projectName(dir) {
+    try {
+        return JSON.parse(readFileSync(join(dir, "package.json"), "utf8")).name ?? dir;
+    }
+    catch {
+        return dir;
+    }
+}
+/** `(external)/hoppscotch` for `src/map/(external)/hoppscotch/_methods/x.block.ts`: the group plus its first folder. */
+function mapGroupOf(file) {
+    const parts = file.split(/[\\/]/);
+    const i = parts.indexOf("map");
+    if (i < 0 || parts[i - 1] !== "src")
+        return undefined;
+    const rest = parts.slice(i + 1, -1);
+    if (rest.length === 0)
+        return undefined;
+    return /^\(.*\)$/.test(rest[0]) && rest[1] && !rest[1].startsWith("_") ? `${rest[0]}/${rest[1]}` : rest[0];
+}
+function useCaseOf(file) {
+    const parts = file.split(/[\\/]/);
+    const i = parts.indexOf("flows");
+    const folders = i >= 0 ? parts.slice(i + 1, -1) : [];
+    return { path: folders, outcome: parts[parts.length - 1].replace(/\.flow\.ts$/, "") };
+}
+/** Builds the manifest from a scan. */
+export function manifestFromScan(scan) {
+    const checkpoints = new Set();
+    const maps = new Set();
+    const blocks = scan.blocks.map((b) => {
+        for (const t of [...b.from, ...b.to])
+            if (t !== "*")
+                checkpoints.add(t);
+        const map = b.map ?? mapGroupOf(b.file);
+        if (map)
+            maps.add(map);
+        return {
+            id: `${b.file}#${b.exportName}`,
+            name: b.name,
+            exportName: b.exportName,
+            kind: b.kind,
+            description: b.description,
+            from: b.from,
+            to: b.to,
+            requires: b.requires,
+            file: b.file,
+            ...(map ? { map } : {}),
+        };
+    });
+    const flows = scan.flows.map((f) => {
+        const flow = f.flow;
+        return {
+            id: `${f.file}#${f.exportName}`,
+            exportName: f.exportName,
+            file: f.file,
+            useCase: useCaseOf(f.file),
+            steps: flow.blocks().map((s) => s.name),
+            settings: {
+                ...(flow.memStub ? { memStub: true } : {}),
+                ...(flow.expectedFailureReason ? { expectedFailure: flow.expectedFailureReason } : {}),
+                ...(flow.resetSession ? { sessionReset: true } : {}),
+                ...(flow.demoPace !== undefined ? { demoPace: flow.demoPace } : {}),
+            },
+        };
+    });
+    return {
+        version: MANIFEST_VERSION,
+        project: { name: projectName(scan.projectDir), dir: scan.projectDir, waygraph: packageVersion() },
+        checkpoints: [...checkpoints].sort(),
+        maps: [...maps].sort(),
+        blocks,
+        flows,
+        skipped: scan.skipped,
+    };
+}
+/** Scans the project and returns its manifest. */
+export async function buildManifest(projectDir, opts = {}) {
+    return manifestFromScan(await scanProject(projectDir, opts));
+}

package/dist/manifest/map-imports.d.ts

@@ -0,0 +1,7 @@
+import type { MapGroup } from "./maps.js";
+export interface MapImportProblem {
+    file: string;
+    spec: string;
+}
+/** Imports in a group that reach outside it. */
+export declare function mapGroupImportProblems(group: MapGroup): MapImportProblem[];

package/dist/manifest/map-imports.js

@@ -0,0 +1,22 @@
+// The rule that makes a map group packable: its files import only waygraph, Playwright, `node:` modules and each other.
+import { dirname, resolve, sep } from "node:path";
+import { walkDir } from "./scan.js";
+import { importSpecifiers, parseSource } from "./source.js";
+const ALLOWED_BARE = /^(waygraph|@playwright\/test|playwright|playwright-core)(\/.*)?$|^node:/;
+/** Imports in a group that reach outside it. */
+export function mapGroupImportProblems(group) {
+    const problems = [];
+    for (const file of walkDir(group.dir, /\.ts$/)) {
+        for (const spec of importSpecifiers(parseSource(file))) {
+            if (spec.startsWith(".")) {
+                const target = resolve(dirname(file), spec);
+                if (target === group.dir || target.startsWith(group.dir + sep))
+                    continue;
+            }
+            else if (ALLOWED_BARE.test(spec))
+                continue;
+            problems.push({ file, spec });
+        }
+    }
+    return problems;
+}

package/dist/manifest/maps.d.ts

@@ -0,0 +1,33 @@
+export interface MapGroup {
+    /** Path under `src/map/`, e.g. `(external)/hoppscotch`. */
+    group: string;
+    dir: string;
+}
+/** Every packable group: a folder under `src/map/` with its own `_states.ts`. */
+export declare function mapGroups(projectDir: string): MapGroup[];
+/** Finds a group by its full path (`(external)/hoppscotch`) or its last folder (`hoppscotch`). */
+export declare function findMapGroup(projectDir: string, name: string): MapGroup | undefined;
+export interface MapPackageJson {
+    version: number;
+    name: string;
+    group: string;
+    checkpoints: string[];
+    blocks: {
+        name: string;
+        exportName: string;
+        kind: string;
+        from: string[];
+        to: string[];
+        requires: string[];
+        file: string;
+    }[];
+}
+export interface InstalledMapPackage {
+    name: string;
+    dir: string;
+    map: MapPackageJson;
+}
+/** Map packages the project depends on: dependencies whose root holds a `waygraph.map.json`. */
+export declare function installedMapPackages(projectDir: string): InstalledMapPackage[];
+/** The compiled Block files of an installed map package. */
+export declare function mapPackageBlockFiles(pkg: InstalledMapPackage): string[];

package/dist/manifest/maps.js

@@ -0,0 +1,62 @@
+// Map groups as packages. A group is a `src/map/` folder that owns its Checkpoints (`_states.ts`); it may import only
+// `waygraph`, Playwright, `node:` modules and its own files, so it can be packed (`waygraph map pack`) and installed in
+// another project, where the scanner finds it by its `waygraph.map.json`.
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { dirname, join, relative, resolve, sep } from "node:path";
+import { walkDir } from "./scan.js";
+/** Every packable group: a folder under `src/map/` with its own `_states.ts`. */
+export function mapGroups(projectDir) {
+    const mapRoot = join(resolve(projectDir), "src", "map");
+    if (!existsSync(mapRoot))
+        return [];
+    return walkDir(mapRoot, /^_states\.ts$/)
+        .map((f) => dirname(f))
+        .map((dir) => ({ group: relative(mapRoot, dir).split(sep).join("/"), dir }))
+        .sort((a, b) => a.group.localeCompare(b.group));
+}
+/** Finds a group by its full path (`(external)/hoppscotch`) or its last folder (`hoppscotch`). */
+export function findMapGroup(projectDir, name) {
+    const groups = mapGroups(projectDir);
+    return groups.find((g) => g.group === name) ?? groups.find((g) => g.group.split("/").pop() === name);
+}
+/** Map packages the project depends on: dependencies whose root holds a `waygraph.map.json`. */
+export function installedMapPackages(projectDir) {
+    let pkg;
+    try {
+        pkg = JSON.parse(readFileSync(join(projectDir, "package.json"), "utf8"));
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const name of Object.keys({ ...pkg.dependencies, ...pkg.devDependencies }).sort()) {
+        const dir = join(projectDir, "node_modules", name);
+        const file = join(dir, "waygraph.map.json");
+        if (!existsSync(file))
+            continue;
+        try {
+            out.push({ name, dir, map: JSON.parse(readFileSync(file, "utf8")) });
+        }
+        catch {
+            /* a broken waygraph.map.json is skipped, like a Block file that fails to import */
+        }
+    }
+    return out;
+}
+/** The compiled Block files of an installed map package. */
+export function mapPackageBlockFiles(pkg) {
+    const files = [];
+    const walk = (dir) => {
+        for (const name of readdirSync(dir)) {
+            const p = join(dir, name);
+            if (name === "node_modules")
+                continue;
+            if (statSync(p).isDirectory())
+                walk(p);
+            else if (/\.block\.js$/.test(name))
+                files.push(p);
+        }
+    };
+    walk(pkg.dir);
+    return files.sort();
+}

package/dist/manifest/pack.d.ts

@@ -0,0 +1,21 @@
+import type { MapImportProblem } from "./map-imports.js";
+export interface PackOptions {
+    /** Output folder. Default `.waygraph/packages/<group>`. */
+    out?: string | undefined;
+    /** Package name. Default `waygraph-map-<group>`. */
+    name?: string | undefined;
+    version?: string | undefined;
+}
+export type PackResult = {
+    ok: true;
+    name: string;
+    dir: string;
+    group: string;
+    blocks: number;
+} | {
+    ok: false;
+    reason: string;
+    problems?: MapImportProblem[];
+};
+/** Packs a map group (by `(external)/hoppscotch` or `hoppscotch`) into an installable package folder. */
+export declare function packMapGroup(projectDir: string, groupName: string, opts?: PackOptions): Promise<PackResult>;