waygraph 0.15.54 → 0.16.1

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>;

package/dist/manifest/pack.js

@@ -0,0 +1,109 @@
+// `waygraph map pack <group>`: compiles one map group with the project's own TypeScript into an installable package
+// (JavaScript + types, an index re-exporting everything, and `waygraph.map.json` for the scanner and Waygraph UI).
+import { spawnSync } from "node:child_process";
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join, relative, resolve, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+import { findMapGroup, mapGroups } from "./maps.js";
+import { mapGroupImportProblems } from "./map-imports.js";
+import { MANIFEST_VERSION } from "./manifest.js";
+import { scanProject } from "./project.js";
+import { walkDir } from "./scan.js";
+function waygraphVersion() {
+    const pkg = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "package.json");
+    return JSON.parse(readFileSync(pkg, "utf8")).version;
+}
+function compile(projectDir, group, out) {
+    let tsc;
+    try {
+        tsc = createRequire(join(projectDir, "package.json")).resolve("typescript/bin/tsc");
+    }
+    catch {
+        return "TypeScript is not installed in this project (npm i -D typescript)";
+    }
+    const base = join(projectDir, "tsconfig.json");
+    const config = join(out, "tsconfig.pack.json");
+    writeFileSync(config, JSON.stringify({
+        ...(existsSync(base) ? { extends: base } : {}),
+        compilerOptions: {
+            ...(existsSync(base) ? {} : { target: "ES2022", module: "NodeNext", moduleResolution: "NodeNext", strict: true, skipLibCheck: true }),
+            noEmit: false,
+            declaration: true,
+            rootDir: group.dir,
+            outDir: out,
+        },
+        include: [join(group.dir, "**", "*.ts")],
+        exclude: [],
+    }, null, 2));
+    const run = spawnSync(process.execPath, [tsc, "-p", config], { cwd: projectDir, encoding: "utf8" });
+    rmSync(config, { force: true });
+    if (run.status !== 0)
+        return `tsc failed:\n${run.stdout}${run.stderr}`;
+    return undefined;
+}
+/** Packs a map group (by `(external)/hoppscotch` or `hoppscotch`) into an installable package folder. */
+export async function packMapGroup(projectDir, groupName, opts = {}) {
+    const group = findMapGroup(projectDir, groupName);
+    if (!group) {
+        const known = mapGroups(projectDir).map((g) => g.group);
+        return {
+            ok: false,
+            reason: `no map group "${groupName}" (a src/map/ folder with its own _states.ts)${known.length ? `; groups: ${known.join(", ")}` : ""}`,
+        };
+    }
+    const problems = mapGroupImportProblems(group);
+    if (problems.length > 0)
+        return { ok: false, reason: `${group.group} imports files outside the group`, problems };
+    const slug = group.group.split("/").pop().replace(/[()]/g, "");
+    const name = opts.name ?? `waygraph-map-${slug}`;
+    const out = resolve(projectDir, opts.out ?? join(".waygraph", "packages", slug));
+    rmSync(out, { recursive: true, force: true });
+    mkdirSync(out, { recursive: true });
+    const failed = compile(projectDir, group, out);
+    if (failed)
+        return { ok: false, reason: failed };
+    const scan = await scanProject(projectDir, { flows: false, maps: false });
+    const blocks = scan.blocks.filter((b) => b.absFile.startsWith(group.dir + sep));
+    const checkpoints = new Set();
+    for (const b of blocks)
+        for (const t of [...b.from, ...b.to])
+            if (t !== "*")
+                checkpoints.add(t);
+    const map = {
+        version: MANIFEST_VERSION,
+        name,
+        group: group.group,
+        checkpoints: [...checkpoints].sort(),
+        blocks: blocks.map((b) => ({
+            name: b.name,
+            exportName: b.exportName,
+            kind: b.kind,
+            from: b.from,
+            to: b.to,
+            requires: b.requires,
+            file: relative(group.dir, b.absFile).split(sep).join("/").replace(/\.ts$/, ".js"),
+        })),
+    };
+    writeFileSync(join(out, "waygraph.map.json"), JSON.stringify(map, null, 2) + "\n");
+    const modules = walkDir(out, /\.js$/)
+        .map((f) => "./" + relative(out, f).split(sep).join("/"))
+        .filter((f) => f !== "./index.js")
+        .sort();
+    const index = modules.map((m) => `export * from "${m}";`).join("\n") + "\n";
+    writeFileSync(join(out, "index.js"), index);
+    writeFileSync(join(out, "index.d.ts"), index);
+    writeFileSync(join(out, "package.json"), JSON.stringify({
+        name,
+        version: opts.version ?? "0.1.0",
+        description: `waygraph map: ${group.group}`,
+        type: "module",
+        main: "./index.js",
+        types: "./index.d.ts",
+        exports: { ".": { types: "./index.d.ts", default: "./index.js" }, "./*": "./*" },
+        files: ["**/*.js", "**/*.d.ts", "waygraph.map.json"],
+        keywords: ["waygraph", "waygraph-map"],
+        peerDependencies: { waygraph: `^${waygraphVersion()}` },
+    }, null, 2) + "\n");
+    return { ok: true, name, dir: out, group: group.group, blocks: blocks.length };
+}

package/dist/manifest/project.d.ts

@@ -0,0 +1,60 @@
+import type { BlocksSelect } from "./select.js";
+import type { AnyBlock } from "./scan.js";
+export type BlockKind = "nav" | "page" | "assert" | "method" | "effect" | "api" | "block";
+export interface ScannedBlock {
+    block: AnyBlock;
+    name: string;
+    exportName: string;
+    kind: BlockKind;
+    description: string;
+    /** Checkpoint tags it runs from (`"*"` = anywhere) and lands on. Empty `to` = route unknown (see `skipped`). */
+    from: string[];
+    to: string[];
+    requires: string[];
+    /** Project-relative path; Blocks from an injected library are tagged `@label/...`. */
+    file: string;
+    absFile: string;
+    /** The installed map package it came from (its `file` is then `<package>/<path>`). */
+    map?: string;
+}
+export interface ScannedFlow {
+    flow: {
+        run: (...args: unknown[]) => Promise<unknown>;
+        blocks: () => unknown[];
+    };
+    exportName: string;
+    file: string;
+    absFile: string;
+}
+/** A Block as the live menus (auto, pilot) hold it: navigation or action. */
+export interface BlockEntry {
+    block: AnyBlock;
+    exportName: string;
+    file: string;
+    kind: "nav" | "action";
+    description: string;
+}
+export interface ProjectScan {
+    projectDir: string;
+    blocks: ScannedBlock[];
+    flows: ScannedFlow[];
+    skipped: {
+        block: string;
+        file: string;
+        reason: string;
+    }[];
+}
+export interface ScanOptions {
+    blocksSelect?: BlocksSelect | undefined;
+    inject?: string[] | undefined;
+    /** Also import `*.flow.ts` files. Default true. */
+    flows?: boolean;
+    /** Also scan installed map packages (dependencies with a `waygraph.map.json`). Default true. */
+    maps?: boolean;
+    /** Called when a file fails to import (default: a one-line warning for Playwright double-install errors). */
+    onImportError?: (relFile: string, err: unknown) => void;
+}
+/** A file that fails to import is left out of the scan, and said so: a silent skip reads as "nothing there". */
+export declare function reportImportError(relFile: string, err: unknown): void;
+/** Imports every `*.block.ts` (and `*.flow.ts`) under the project and its injected roots. */
+export declare function scanProject(projectDir: string, opts?: ScanOptions): Promise<ProjectScan>;

package/dist/manifest/project.js

@@ -0,0 +1,101 @@
+// Scans a project (and any injected Block libraries) into its Blocks and Flows, with each Block's route.
+import { relative } from "node:path";
+import { matchBlocksSelect } from "./select.js";
+import { exploreRoots, injectTaggedFile } from "./roots.js";
+import { blockKind, importFresh, isBlockLike, isFlowLike, walkDir } from "./scan.js";
+import { installedMapPackages, mapPackageBlockFiles } from "./maps.js";
+function kindOf(block) {
+    const kind = blockKind(block);
+    if (kind === "nav" || kind === "page" || kind === "assert" || kind === "api")
+        return kind;
+    const salt = block.__waygraphSalt;
+    if (salt === "effect" || salt === "method" || salt === "api")
+        return salt;
+    return "block";
+}
+/** A file that fails to import is left out of the scan, and said so: a silent skip reads as "nothing there". */
+export function reportImportError(relFile, err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`waygraph: skip ${relFile}: ${msg.split("\n")[0]}`);
+}
+/** Imports every `*.block.ts` (and `*.flow.ts`) under the project and its injected roots. */
+export async function scanProject(projectDir, opts = {}) {
+    const select = opts.blocksSelect;
+    const onError = opts.onImportError ?? reportImportError;
+    const blocks = [];
+    const flows = [];
+    const skipped = [];
+    const scanBlockFile = async (absFile, rel, file, map) => {
+        let mod;
+        try {
+            mod = await importFresh(absFile);
+        }
+        catch (err) {
+            onError(rel, err);
+            return;
+        }
+        for (const [exportName, exported] of Object.entries(mod)) {
+            if (!isBlockLike(exported))
+                continue;
+            if (select && !matchBlocksSelect(select, { relFile: file, blockName: exported.name }))
+                continue;
+            const marked = exported;
+            const from = marked.__waygraphFrom ?? [];
+            const to = marked.__waygraphTo ?? [];
+            // Every factory records a route; only a bare defineBlock has none.
+            if (to.length === 0)
+                skipped.push({ block: exported.name, file, reason: "no route: build it with a define*Block factory and Checkpoint values" });
+            blocks.push({
+                block: exported,
+                name: exported.name,
+                exportName,
+                kind: kindOf(exported),
+                description: typeof exported.description === "string" ? exported.description : "",
+                from: [...from],
+                to: [...to],
+                requires: (exported.requires ?? []).map((k) => k.name),
+                file,
+                absFile,
+                ...(map ? { map } : {}),
+            });
+        }
+    };
+    for (const root of exploreRoots(projectDir, opts.inject)) {
+        let files = walkDir(root, /\.block\.ts$/);
+        if (select && select.kind !== "regex") {
+            files = files.filter((f) => matchBlocksSelect(select, { relFile: relative(root, f).replace(/\\/g, "/") }));
+        }
+        for (const absFile of files) {
+            const rel = relative(root, absFile).replace(/\\/g, "/");
+            await scanBlockFile(absFile, rel, injectTaggedFile(projectDir, root, rel));
+        }
+        if (opts.flows === false)
+            continue;
+        for (const absFile of walkDir(root, /\.flow\.ts$/)) {
+            const rel = relative(root, absFile).replace(/\\/g, "/");
+            let mod;
+            try {
+                mod = await importFresh(absFile);
+            }
+            catch (err) {
+                onError(rel, err);
+                continue;
+            }
+            for (const [exportName, exported] of Object.entries(mod)) {
+                if (isFlowLike(exported))
+                    flows.push({ flow: exported, exportName, file: injectTaggedFile(projectDir, root, rel), absFile });
+            }
+        }
+    }
+    if (opts.maps !== false) {
+        for (const pkg of installedMapPackages(projectDir)) {
+            for (const absFile of mapPackageBlockFiles(pkg)) {
+                const rel = relative(pkg.dir, absFile).replace(/\\/g, "/");
+                if (select && select.kind !== "regex" && !matchBlocksSelect(select, { relFile: `${pkg.name}/${rel}` }))
+                    continue;
+                await scanBlockFile(absFile, rel, `${pkg.name}/${rel}`, pkg.name);
+            }
+        }
+    }
+    return { projectDir, blocks, flows, skipped };
+}

package/dist/{session/block-inject.js → manifest/roots.js}

@@ -5,12 +5,9 @@
 import { existsSync } from "node:fs";
 import { basename, dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { homedir } from "node:os";
 /**
  * This package's own installed root (contains `templates/`/`examples/`, sibling to `dist/`) -
- * this file compiles to `dist/session/block-inject.js`, two levels down, not one. Same class of
- * bug as `cli/util.ts`'s own `packageRoot()` (see its comment) - self-inflicted here by moving
- * this file into `src/session/` without updating the path math to match the new depth.
+ * this file compiles to `dist/manifest/roots.js`, two levels down.
  */
 function packageRoot() {
     return resolve(dirname(fileURLToPath(import.meta.url)), "..", "..");
@@ -32,20 +29,6 @@ export function injectTaggedFile(hostDir, root, relFile) {
 }
 const PRESETS = {
     saucedemo: () => join(packageRoot(), "examples", "saucedemo"),
-    demosauce: () => join(packageRoot(), "examples", "saucedemo"),
-    veciro: () => {
-        if (process.env.WAYGRAPH_INJECT_VECIRO) {
-            return resolve(process.env.WAYGRAPH_INJECT_VECIRO);
-        }
-        for (const c of [
-            join(homedir(), "Desktop", "Work", "veciro-waygraph"),
-            join(homedir(), "Desktop", "Projects", "veciro-waygraph"),
-        ]) {
-            if (existsSync(c))
-                return c;
-        }
-        return null;
-    },
 };
 /**
  * Resolve one `--inject` token to an absolute directory (preset name or path).

package/dist/manifest/scan.d.ts

@@ -0,0 +1,19 @@
+import type { Block } from "../engine/block/block.js";
+import type { Checkpoint } from "../engine/checkpoint/checkpoint.js";
+/** Every file under `dir` whose name matches, skipping `node_modules`, `dist` and `.git`. */
+export declare function walkDir(dir: string, pattern: RegExp): string[];
+/**
+ * Imports a project file. The file's mtime is part of the URL: Node caches an ESM import per specifier for the life of the
+ * process, so a long-running session reloading an edited Block would otherwise keep the first version.
+ */
+export declare function importFresh(filePath: string): Promise<Record<string, unknown>>;
+export type AnyBlock = Block<Checkpoint<string>, Checkpoint<string>> & {
+    description?: string;
+};
+export declare function isBlockLike(val: unknown): val is AnyBlock;
+export declare function isFlowLike(val: unknown): val is {
+    run: (...args: unknown[]) => Promise<unknown>;
+    blocks: () => unknown[];
+};
+/** The factory kind a Block was built with (`nav`, `page`, `assert`), or undefined for Methods and Effects. */
+export declare function blockKind(block: object): string | undefined;