@sequenceholdings/studio-cli 0.1.9

package/dist/process/local-bundle.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Load a lattice bundle from disk for `bundle publish`. Mirrors the
+ * `seq-studio bundle publish` local store layout.
+ */
+import { type LatticeBundle } from '@sequenceholdings/lattice/bundle';
+export declare function resolveLocalBundleRoot(): string;
+/**
+ * Hash-on-read integrity check — same contract as LocalFsBundleStore.get()
+ * so hand-edited bundle.json files fail locally before POST /bundles.
+ */
+export declare function validateBundleIntegrity({ bundle, context, }: {
+    bundle: LatticeBundle;
+    context: string;
+}): void;
+export declare function loadBundleForPublish({ hashOrPath, }: {
+    hashOrPath: string;
+}): Promise<LatticeBundle>;

package/dist/process/local-bundle.js

@@ -0,0 +1,65 @@
+/**
+ * Load a lattice bundle from disk for `bundle publish`. Mirrors the
+ * `seq-studio bundle publish` local store layout.
+ */
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { BUNDLE_SCHEMA_VERSION, BundleHashMismatchError, computePublishedBundleHash, LocalFsBundleStore, MAX_LATTICE_BUNDLE_BYTES, } from '@sequenceholdings/lattice/bundle';
+const HASH_PATTERN = /^[a-f0-9]{64}$/;
+export function resolveLocalBundleRoot() {
+    return (process.env['LATTICE_LOCAL_BUNDLE_ROOT']?.trim() ||
+        resolve(process.cwd(), '.lattice'));
+}
+/**
+ * Hash-on-read integrity check — same contract as LocalFsBundleStore.get()
+ * so hand-edited bundle.json files fail locally before POST /bundles.
+ */
+export function validateBundleIntegrity({ bundle, context, }) {
+    if (bundle.schema_version !== BUNDLE_SCHEMA_VERSION) {
+        throw new Error(`${context}: schema_version must be ${BUNDLE_SCHEMA_VERSION}, got ${String(bundle.schema_version)}`);
+    }
+    if (!HASH_PATTERN.test(bundle.bundle_hash)) {
+        throw new Error(`${context}: bundle_hash must be a 64-char hex string`);
+    }
+    const expected = computePublishedBundleHash({
+        manifest: bundle.manifest,
+        processes: bundle.processes,
+    });
+    if (bundle.bundle_hash !== expected) {
+        throw new BundleHashMismatchError(expected, bundle.bundle_hash, context);
+    }
+    const byteLen = Buffer.byteLength(JSON.stringify(bundle), 'utf8');
+    if (byteLen > MAX_LATTICE_BUNDLE_BYTES) {
+        throw new Error(`${context}: bundle is ${byteLen} bytes; exceeds ${MAX_LATTICE_BUNDLE_BYTES} byte limit`);
+    }
+}
+export async function loadBundleForPublish({ hashOrPath, }) {
+    if (hashOrPath.endsWith('.json')) {
+        const path = resolve(hashOrPath);
+        let body;
+        try {
+            body = await readFile(path, 'utf8');
+        }
+        catch (err) {
+            throw new Error(`could not read bundle file ${path}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        let bundle;
+        try {
+            bundle = JSON.parse(body);
+        }
+        catch (err) {
+            throw new Error(`invalid JSON in ${path}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        validateBundleIntegrity({ bundle, context: path });
+        return bundle;
+    }
+    if (!HASH_PATTERN.test(hashOrPath)) {
+        throw new Error(`expected a 64-char bundle hash or a .json path, got: ${hashOrPath}`);
+    }
+    const store = new LocalFsBundleStore({ root: resolveLocalBundleRoot() });
+    const bundle = await store.get(hashOrPath);
+    if (!bundle) {
+        throw new Error(`bundle ${hashOrPath} not found in ${store.describe()}`);
+    }
+    return bundle;
+}

package/dist/process/plan-diff.d.ts

@@ -0,0 +1,82 @@
+/**
+ * Diff a freshly-built bundle against the currently-active bundle for
+ * each process. Used by `seq-studio process plan` to surface what changes for new
+ * runs (in-flight runs are pinned to their original bundle, so any diff
+ * is informational — not a correctness risk).
+ */
+import type { LatticeBundle, SerializedProcess } from '@sequenceholdings/lattice/bundle';
+export interface PlanDiff {
+    processes: readonly ProcessDiff[];
+    has_breaking_change: boolean;
+}
+export interface ProcessDiff {
+    process_id: string;
+    status: 'unchanged' | 'new' | 'updated';
+    /**
+     * Set when `start_node_id` changes between active and next. Always
+     * BREAKING for new runs because the orchestrator starts a different
+     * node — surface it separately from per-node changes so the plan
+     * summary makes the entry point visible.
+     */
+    start_node_changed?: {
+        from: string;
+        to: string;
+    };
+    added_nodes: readonly string[];
+    removed_nodes: readonly string[];
+    changed_nodes: readonly NodeChange[];
+    added_edges: readonly {
+        node_id: string;
+        edge_id: string;
+        to: string;
+    }[];
+    removed_edges: readonly {
+        node_id: string;
+        edge_id: string;
+        to: string;
+    }[];
+    retargeted_edges: readonly {
+        node_id: string;
+        edge_id: string;
+        from: string;
+        to: string;
+    }[];
+    active_version?: string;
+    new_version?: string;
+    is_breaking: boolean;
+}
+export interface NodeChange {
+    node_id: string;
+    kind_changed?: {
+        from: string;
+        to: string;
+    };
+    agent_ref_changed?: {
+        from: string | undefined;
+        to: string | undefined;
+    };
+    outgoing_edges_changed?: boolean;
+    /**
+     * Set when behavior-affecting metadata on the node changes — for
+     * sandboxed automation nodes that means `function_version`,
+     * `function_id`, or `input_mapper_source`; for native automation nodes
+     * `registered_function_id`, `config`, or `limits`; for agent nodes
+     * `input_mapper_source` or `timeout`; for human nodes `artifact_refs`,
+     * `comments`, `timeout`, `on_timeout_edge_id`, `artifact_refs_mapper_source`,
+     * `advance_allowed`, or `advance_allowed_mapper_source`.
+     * Without this check a process whose `fn` changed but graph topology
+     * stayed identical would diff as "unchanged" and `process test`
+     * would stay green even though new runs would execute different
+     * code.
+     */
+    metadata_fields_changed?: readonly string[];
+}
+export type LoadActiveProcess = (processId: string) => Promise<{
+    version: string;
+    process: SerializedProcess;
+} | null>;
+export declare function diffBundleAgainstActive(input: {
+    newBundle: LatticeBundle;
+    loadActiveProcess: LoadActiveProcess;
+}): Promise<PlanDiff>;
+export declare function formatPlanDiff(diff: PlanDiff): string;

package/dist/process/plan-diff.js

@@ -0,0 +1,333 @@
+/**
+ * Diff a freshly-built bundle against the currently-active bundle for
+ * each process. Used by `seq-studio process plan` to surface what changes for new
+ * runs (in-flight runs are pinned to their original bundle, so any diff
+ * is informational — not a correctness risk).
+ */
+export async function diffBundleAgainstActive(input) {
+    const processDiffs = [];
+    for (const newProc of input.newBundle.processes) {
+        const active = await input.loadActiveProcess(newProc.id);
+        if (!active) {
+            processDiffs.push({
+                process_id: newProc.id,
+                status: 'new',
+                added_nodes: newProc.nodes.map((n) => n.id),
+                removed_nodes: [],
+                changed_nodes: [],
+                added_edges: flattenEdges(newProc.nodes),
+                removed_edges: [],
+                retargeted_edges: [],
+                new_version: input.newBundle.version,
+                is_breaking: false,
+            });
+            continue;
+        }
+        const diff = diffProcesses(active.process, newProc);
+        processDiffs.push({
+            process_id: newProc.id,
+            status: diff.unchanged ? 'unchanged' : 'updated',
+            ...(diff.startNodeChanged ? { start_node_changed: diff.startNodeChanged } : {}),
+            added_nodes: diff.addedNodes,
+            removed_nodes: diff.removedNodes,
+            changed_nodes: diff.changedNodes,
+            added_edges: diff.addedEdges,
+            removed_edges: diff.removedEdges,
+            retargeted_edges: diff.retargetedEdges,
+            active_version: active.version,
+            new_version: input.newBundle.version,
+            is_breaking: diff.isBreaking,
+        });
+    }
+    return {
+        processes: processDiffs,
+        has_breaking_change: processDiffs.some((p) => p.is_breaking),
+    };
+}
+function diffProcesses(active, next) {
+    const startNodeChanged = active.start_node_id !== next.start_node_id
+        ? { from: active.start_node_id, to: next.start_node_id }
+        : undefined;
+    const activeNodeIds = new Set(active.nodes.map((n) => n.id));
+    const nextNodeIds = new Set(next.nodes.map((n) => n.id));
+    const removedNodes = [...activeNodeIds].filter((id) => !nextNodeIds.has(id));
+    const addedNodes = [...nextNodeIds].filter((id) => !activeNodeIds.has(id));
+    const changedNodes = [];
+    for (const id of activeNodeIds) {
+        if (!nextNodeIds.has(id))
+            continue;
+        const a = active.nodes.find((n) => n.id === id);
+        const b = next.nodes.find((n) => n.id === id);
+        const change = diffNode(a, b);
+        if (change)
+            changedNodes.push(change);
+    }
+    const removedEdges = [];
+    const addedEdges = [];
+    const retargetedEdges = [];
+    for (const node of active.nodes) {
+        if (!nextNodeIds.has(node.id))
+            continue;
+        const nextNode = next.nodes.find((n) => n.id === node.id);
+        const activeEdges = new Map(node.outgoing_edges.map((e) => [e.id, e]));
+        const nextEdges = new Map(nextNode.outgoing_edges.map((e) => [e.id, e]));
+        for (const [id, edge] of activeEdges) {
+            const nextEdge = nextEdges.get(id);
+            if (!nextEdge) {
+                removedEdges.push({ node_id: node.id, edge_id: id, to: edge.to });
+            }
+            else if (nextEdge.to !== edge.to) {
+                retargetedEdges.push({
+                    node_id: node.id,
+                    edge_id: id,
+                    from: edge.to,
+                    to: nextEdge.to,
+                });
+            }
+        }
+        for (const [id, edge] of nextEdges) {
+            if (!activeEdges.has(id)) {
+                addedEdges.push({ node_id: node.id, edge_id: id, to: edge.to });
+            }
+        }
+    }
+    for (const node of next.nodes) {
+        if (activeNodeIds.has(node.id))
+            continue;
+        for (const e of node.outgoing_edges) {
+            addedEdges.push({ node_id: node.id, edge_id: e.id, to: e.to });
+        }
+    }
+    const isBreaking = startNodeChanged != null ||
+        removedNodes.length > 0 ||
+        removedEdges.length > 0 ||
+        retargetedEdges.length > 0 ||
+        changedNodes.some((c) => c.kind_changed != null || c.agent_ref_changed != null);
+    const unchanged = startNodeChanged == null &&
+        removedNodes.length === 0 &&
+        addedNodes.length === 0 &&
+        changedNodes.length === 0 &&
+        removedEdges.length === 0 &&
+        addedEdges.length === 0 &&
+        retargetedEdges.length === 0;
+    return {
+        unchanged,
+        ...(startNodeChanged ? { startNodeChanged } : {}),
+        addedNodes,
+        removedNodes,
+        changedNodes,
+        addedEdges,
+        removedEdges,
+        retargetedEdges,
+        isBreaking,
+    };
+}
+/**
+ * Per-kind set of metadata fields that, when changed, alter behavior
+ * for new runs. Kept narrow on purpose: cosmetic/non-behavioral fields
+ * (like display labels added later) should NOT show up here or we'd
+ * report "changed" for no reason.
+ *
+ * Source of truth for what populates metadata is
+ * `serializeNodeMetadata` in `process/build.ts`.
+ */
+const BEHAVIORAL_METADATA_FIELDS = {
+    // `registered_function_id` is the discriminator for native automation
+    // nodes — switching which registered function a node runs is a behavior
+    // change for new runs (and produces a new bundle hash), so it must diff
+    // as "updated" rather than silently passing `process test`.
+    automation: [
+        'function_version',
+        'function_id',
+        'input_mapper_source',
+        'registered_function_id',
+        // Native automation nodes: static config (e.g. a target resource id) and
+        // limits alter which function runs and with what budget.
+        'config',
+        'limits',
+        'middleware',
+    ],
+    agent: ['input_mapper_source', 'timeout', 'workflow_id', 'middleware', 'on_reset_edge_id'],
+    // managed_function: the target ref, version pin, output/timeout budget,
+    // input mapper, and middleware (e.g. retry) all alter what runs for new runs.
+    managed_function: ['function_id', 'version', 'limits', 'input_mapper_source', 'middleware'],
+    human: [
+        'artifact_refs',
+        'artifact_refs_mapper_source',
+        'comments',
+        'input_mapper_source',
+        'timeout',
+        'on_timeout_edge_id',
+        'metadata',
+        // The advance ACL decides who may advance the step. Both the static
+        // object form and the `(ctx) => ACL` mapper source change who gets the
+        // advancer tuples on new runs, so a change to either must diff as
+        // behavioral (otherwise `process test` stays green on an auth change).
+        'advance_allowed',
+        'advance_allowed_mapper_source',
+        // dueDate fn computes the task's due instant at parking — a change alters
+        // run behavior (inbox due pill/sort), so it must diff as behavioral.
+        'due_date_source',
+    ],
+};
+/** Nested `metadata.subprocess` fields that change behavior for new parent runs. */
+const SUBPROCESS_BEHAVIORAL_FIELDS = [
+    'process_id',
+    'version',
+    'bundle_hash',
+    'on_child_error',
+    'output_mapper_source',
+];
+function diffNode(a, b) {
+    const change = { node_id: a.id };
+    let any = false;
+    if (a.kind !== b.kind) {
+        change.kind_changed = { from: a.kind, to: b.kind };
+        any = true;
+    }
+    const aAgentId = a.metadata.agent_id;
+    const bAgentId = b.metadata.agent_id;
+    if (aAgentId !== bAgentId) {
+        change.agent_ref_changed = { from: aAgentId, to: bAgentId };
+        any = true;
+    }
+    const aEdges = a.outgoing_edges.map((e) => `${e.id}->${e.to}`).sort().join(',');
+    const bEdges = b.outgoing_edges.map((e) => `${e.id}->${e.to}`).sort().join(',');
+    if (aEdges !== bEdges) {
+        change.outgoing_edges_changed = true;
+        any = true;
+    }
+    // Behavioral-metadata sweep. Only run when both sides share the same
+    // kind — a kind change is already surfaced via `kind_changed` and
+    // would double-count metadata noise from the kind transition.
+    if (a.kind === b.kind) {
+        const fields = BEHAVIORAL_METADATA_FIELDS[a.kind] ?? [];
+        const metaA = a.metadata;
+        const metaB = b.metadata;
+        const changed = [];
+        for (const f of fields) {
+            // agent_ref_changed already surfaces metadata.agent_id; skip
+            // here to avoid double-reporting.
+            if (a.kind === 'agent' && f === 'agent_id')
+                continue;
+            if (!stableEqual(metaA[f], metaB[f])) {
+                changed.push(f);
+            }
+        }
+        if (changed.length > 0) {
+            change.metadata_fields_changed = changed;
+            any = true;
+        }
+    }
+    if (a.kind === 'subprocess' && b.kind === 'subprocess') {
+        const metaA = a.metadata;
+        const metaB = b.metadata;
+        const spA = (metaA.subprocess ?? {});
+        const spB = (metaB.subprocess ?? {});
+        const subprocessChanged = [];
+        for (const f of SUBPROCESS_BEHAVIORAL_FIELDS) {
+            if (!stableEqual(spA[f], spB[f])) {
+                subprocessChanged.push(`subprocess.${f}`);
+            }
+        }
+        if (!stableEqual(metaA.input_mapper_source, metaB.input_mapper_source)) {
+            subprocessChanged.push('input_mapper_source');
+        }
+        if (subprocessChanged.length > 0) {
+            change.metadata_fields_changed = [
+                ...(change.metadata_fields_changed ?? []),
+                ...subprocessChanged,
+            ];
+            any = true;
+        }
+    }
+    return any ? change : null;
+}
+/**
+ * Stable structural equality for JSON-compatible values. Order matters
+ * for arrays (intentional — `artifact_refs[0]` vs `[1]` is a real
+ * behavior difference) but not for plain object keys.
+ */
+function stableEqual(a, b) {
+    if (a === b)
+        return true;
+    if (a == null || b == null)
+        return a === b;
+    if (typeof a !== typeof b)
+        return false;
+    if (Array.isArray(a)) {
+        if (!Array.isArray(b) || a.length !== b.length)
+            return false;
+        for (let i = 0; i < a.length; i++) {
+            if (!stableEqual(a[i], b[i]))
+                return false;
+        }
+        return true;
+    }
+    if (typeof a === 'object') {
+        const aObj = a;
+        const bObj = b;
+        const ak = Object.keys(aObj).sort();
+        const bk = Object.keys(bObj).sort();
+        if (ak.length !== bk.length)
+            return false;
+        for (let i = 0; i < ak.length; i++) {
+            if (ak[i] !== bk[i])
+                return false;
+            if (!stableEqual(aObj[ak[i]], bObj[bk[i]]))
+                return false;
+        }
+        return true;
+    }
+    return false;
+}
+function flattenEdges(nodes) {
+    const out = [];
+    for (const n of nodes) {
+        for (const e of n.outgoing_edges) {
+            out.push({ node_id: n.id, edge_id: e.id, to: e.to });
+        }
+    }
+    return out;
+}
+export function formatPlanDiff(diff) {
+    const lines = [];
+    for (const p of diff.processes) {
+        lines.push(`process ${p.process_id}: ${p.status}${p.is_breaking ? ' (BREAKING)' : ''}`);
+        if (p.active_version || p.new_version) {
+            lines.push(`  active=${p.active_version ?? '<none>'} → new=${p.new_version ?? '<none>'}`);
+        }
+        if (p.start_node_changed) {
+            lines.push(`  ! start_node_id: ${p.start_node_changed.from} → ${p.start_node_changed.to} (BREAKING)`);
+        }
+        if (p.added_nodes.length > 0)
+            lines.push(`  + nodes: ${p.added_nodes.join(', ')}`);
+        if (p.removed_nodes.length > 0)
+            lines.push(`  - nodes: ${p.removed_nodes.join(', ')}`);
+        for (const c of p.changed_nodes) {
+            const bits = [];
+            if (c.kind_changed)
+                bits.push(`kind ${c.kind_changed.from}→${c.kind_changed.to}`);
+            if (c.agent_ref_changed)
+                bits.push(`agent ${c.agent_ref_changed.from ?? '<none>'}→${c.agent_ref_changed.to ?? '<none>'}`);
+            if (c.outgoing_edges_changed)
+                bits.push(`outgoing_edges changed`);
+            if (c.metadata_fields_changed && c.metadata_fields_changed.length > 0) {
+                bits.push(`metadata: ${c.metadata_fields_changed.join(', ')}`);
+            }
+            lines.push(`  ~ ${c.node_id}: ${bits.join('; ')}`);
+        }
+        for (const e of p.added_edges) {
+            lines.push(`  + edge ${e.node_id}/${e.edge_id} → ${e.to}`);
+        }
+        for (const e of p.removed_edges) {
+            lines.push(`  - edge ${e.node_id}/${e.edge_id} → ${e.to}`);
+        }
+        for (const e of p.retargeted_edges) {
+            lines.push(`  ~ edge ${e.node_id}/${e.edge_id}: ${e.from} → ${e.to}`);
+        }
+    }
+    if (lines.length === 0)
+        lines.push('no changes');
+    return lines.join('\n');
+}

package/dist/process/resolve-process-pin.d.ts

@@ -0,0 +1,11 @@
+import type { ResolveProcessPin } from './build.js';
+import type { ResolvedEnv } from '../config.js';
+/**
+ * Build a registry lookup that resolves a child process id (+ optional version)
+ * to { version, bundleHash } for subprocess pin resolution at bundle build.
+ */
+export declare function buildResolveProcessPin(input: {
+    baseUrl: string;
+    token: string;
+}): ResolveProcessPin;
+export declare function buildResolveProcessPinFromEnv(env: ResolvedEnv, token: string): ResolveProcessPin;

package/dist/process/resolve-process-pin.js

@@ -0,0 +1,63 @@
+import { getJsonOr404 } from '../atlas-client.js';
+/**
+ * Build a registry lookup that resolves a child process id (+ optional version)
+ * to { version, bundleHash } for subprocess pin resolution at bundle build.
+ */
+export function buildResolveProcessPin(input) {
+    return async (processId, version) => {
+        if (version) {
+            const row = await getJsonOr404({
+                baseUrl: input.baseUrl,
+                token: input.token,
+                path: `/api/lattice/processes/${encodeURIComponent(processId)}/versions/${encodeURIComponent(version)}`,
+            });
+            if (!row)
+                return null;
+            const bundleHash = await resolveBundleHashForVersion({
+                baseUrl: input.baseUrl,
+                token: input.token,
+                processId,
+                version,
+            });
+            return bundleHash ? { version, bundleHash } : null;
+        }
+        const meta = await getJsonOr404({
+            baseUrl: input.baseUrl,
+            token: input.token,
+            path: `/api/lattice/processes/${encodeURIComponent(processId)}`,
+        });
+        if (!meta?.activeVersion || !meta.activeBundleHash)
+            return null;
+        return { version: meta.activeVersion, bundleHash: meta.activeBundleHash };
+    };
+}
+export function buildResolveProcessPinFromEnv(env, token) {
+    return buildResolveProcessPin({ baseUrl: env.url, token });
+}
+async function resolveBundleHashForVersion(input) {
+    const meta = await getJsonOr404({
+        baseUrl: input.baseUrl,
+        token: input.token,
+        path: `/api/lattice/processes/${encodeURIComponent(input.processId)}`,
+    });
+    if (meta?.activeVersion === input.version && meta.activeBundleHash) {
+        return meta.activeBundleHash;
+    }
+    let cursor;
+    for (;;) {
+        const path = `/api/lattice/processes/${encodeURIComponent(input.processId)}/versions` +
+            (cursor ? `?cursor=${encodeURIComponent(cursor)}` : '');
+        const page = await getJsonOr404({
+            baseUrl: input.baseUrl,
+            token: input.token,
+            path,
+        });
+        const hit = page?.versions?.find((v) => v.version === input.version);
+        if (hit?.bundle_hash)
+            return hit.bundle_hash;
+        cursor = page?.next_cursor ?? undefined;
+        if (!cursor)
+            break;
+    }
+    return null;
+}

package/dist/process/simulate.d.ts

@@ -0,0 +1,50 @@
+/**
+ * In-process orchestrator walker with stubbed runners. Lets process
+ * authors verify their graph topology + routing locally without
+ * deploying to Trigger.dev.
+ *
+ * Mirrors the production orchestrator's `verifyAndAdvance` loop but:
+ *   - Skips DB persistence
+ *   - Stubs agent runner with the first outgoing edge + synthetic payload
+ *   - Stubs human runner identically (or accepts caller-supplied decisions)
+ *   - Stubs automation runner identically — native handlers live in the
+ *     Atlas image and can't execute here
+ */
+import { type ProcessDefinition } from '@sequenceholdings/lattice/define';
+import type { JsonObject, NodeKind, NodeOutput } from '@sequenceholdings/lattice';
+export interface SimulateOptions {
+    process: ProcessDefinition;
+    /** All loaded process definitions — required to simulate subprocess nodes. */
+    processesById?: ReadonlyMap<string, ProcessDefinition>;
+    entity?: {
+        type: string;
+        id: string;
+    };
+    /** Child run metadata — surfaced as ctx.run.metadata (subprocess input mapper). */
+    metadata?: JsonObject;
+    startNodeId?: string;
+    humanDecisions?: Record<string, NodeOutput>;
+    maxIterations?: number;
+    maxRevisits?: number;
+    state?: JsonObject;
+}
+export interface SimulateResult {
+    steps: readonly SimulateStep[];
+    status: 'completed' | 'failed';
+    error?: string;
+}
+export interface SimulateStep {
+    iteration: number;
+    node_id: string;
+    kind: NodeKind;
+    input: unknown;
+    output: NodeOutput;
+    next_edge_id?: string;
+    to_node_id?: string;
+    /** Set on sub-steps emitted by a parallel block branch. */
+    branch_id?: string;
+    /** The parallel node id this sub-step belongs to (set on sub-steps). */
+    parent_node_id?: string;
+}
+export declare function simulateProcess(opts: SimulateOptions): Promise<SimulateResult>;
+export declare function formatSimulateResult(result: SimulateResult): string;