@uipath/maestro-builder-sdk 5.2.0

package/dist/case/compile-cli.js

@@ -0,0 +1,291 @@
+#!/usr/bin/env node
+/**
+ * compile-cli — <Name>.case.ts → caseplan.json
+ *
+ * Usage:
+ *   node --experimental-strip-types compile-cli.js <case.ts | BaseName> [-o out.json]
+ *
+ * Runs the fast static check first; if it passes, serializes to a V30
+ * caseplan.json. The authoritative deploy gate is `uip maestro case validate`.
+ * Output defaults to `caseplan.json` (the platform's canonical file name).
+ */
+import { writeFileSync, readFileSync, existsSync } from 'node:fs';
+import { join, dirname, basename } from 'node:path';
+import { createHash } from 'node:crypto';
+import { resolveCaseFile, loadBuiltCase } from './load.js';
+import { serialize } from './serialize.js';
+import { check } from './check.js';
+import { entryPointIO } from './entry-points.js';
+import { Library } from '../core/library.js';
+import { Bindings } from '../core/bindings.js';
+import { resolveLibraryDir } from '../registry/cache.js';
+import { runWhenInvokedDirectly } from '../cli-run.js';
+import { ensureTypeScriptRuntime } from '../node-runtime.js';
+import { CASE_FORMAT_PROFILE } from './format-profile.js';
+function opt(argv, name) {
+    const i = argv.indexOf(name);
+    return i >= 0 ? argv[i + 1] : undefined;
+}
+export async function run(argv) {
+    if (argv.length === 0 || argv[0] === '-h' || argv[0] === '--help') {
+        console.error('usage: compile <case.ts | BaseName> [-o caseplan.json]');
+        return 2;
+    }
+    const flags = new Set(['-o', '--library', '--bindings', '--connectors-local']);
+    const pos = argv.find((a, i) => !flags.has(a) && !flags.has(argv[i - 1]));
+    if (!pos) {
+        console.error('compile: missing <case.ts | BaseName>');
+        return 2;
+    }
+    const file = resolveCaseFile(pos);
+    ensureTypeScriptRuntime();
+    const built = await loadBuiltCase(file);
+    const diags = check(built);
+    for (const d of diags)
+        console.error(`  ${d.level === 'error' ? '✗' : '⚠'} [${d.code}] ${d.message}`);
+    const errors = diags.filter((d) => d.level === 'error');
+    if (errors.length) {
+        console.error(`compile: ${errors.length} error(s); not emitting.`);
+        return 1;
+    }
+    // Connector tasks resolve against the library; load it only when present, and
+    // bindings.json from alongside the case when present. Resolved through the same
+    // helper Flow and BPMN use, so `registry pull` serves all three families —
+    // reading the env directly skipped the shared cache, and a Case that compiled
+    // fine right after a pull on Flow failed here for no visible reason.
+    const libDir = resolveLibraryDir(opt(argv, '--library'));
+    // A `prepare-connector` overlay, auto-detected next to the case (like bindings.json).
+    const overlayDir = opt(argv, '--connectors-local')
+        ?? (existsSync(join('connectors-local', 'index.json')) ? 'connectors-local' : undefined);
+    const library = libDir && existsSync(join(libDir, 'index.json')) ? new Library(libDir, { overlayDir }) : undefined;
+    const bindFile = opt(argv, '--bindings') ?? (existsSync('bindings.json') ? 'bindings.json' : undefined);
+    const bindings = new Bindings(bindFile);
+    const caseplan = serialize(built, { library, bindings });
+    const out = opt(argv, '-o') ?? 'caseplan.json';
+    writeFileSync(out, JSON.stringify(caseplan, null, 2) + '\n');
+    const stages = caseplan.nodes.filter((n) => String(n.type).endsWith('Stage')).length;
+    const triggers = syncEntryPoints(caseplan, out);
+    const epNote = triggers >= 0 ? `, synced entry-points.json (${triggers} trigger(s))` : '';
+    const resources = syncBindingsV2(caseplan, out);
+    const bindingsNote = resources >= 0 ? `, synced bindings_v2.json (${resources} resource(s))` : '';
+    console.log(`compile: wrote ${out} (${stages} stage(s))${epNote}${bindingsNote}`);
+    return 0;
+}
+/**
+ * The name of the case file THE PACKAGE SHIPS, which is what an entry point's
+ * `filePath` has to name — not the name this compile happened to write.
+ *
+ * These diverge on the documented brownfield loop. `case decompile` generates a
+ * pipeline that compiles to `<Name>.caseplan.json` and then merges into the
+ * project's `caseplan.json`, so a `basename(outPath)` entry point pointed at
+ * `/content/LinearThreeStages.caseplan.json.bpmn` — a file no package contains,
+ * because the packaged pair is `caseplan.json` + `caseplan.json.bpmn`. The eval
+ * task that took that path never left `Pending (0/0 elements completed)`: the
+ * debug instance was created and no element ever started.
+ *
+ * `package-descriptor.json` is the project's own declaration of what it ships
+ * and `uip maestro case init` writes it beside `entry-points.json`, so it is the
+ * authority whenever it is there.
+ */
+function packagedCaseFileName(dir, outPath) {
+    const descriptorPath = join(dir, 'package-descriptor.json');
+    if (existsSync(descriptorPath)) {
+        try {
+            const files = JSON.parse(readFileSync(descriptorPath, 'utf8'))?.files;
+            if (files && typeof files === 'object') {
+                // The descriptor keys the pair by logical name; the case file is the one
+                // whose BPMN sibling it also ships.
+                const named = Object.keys(files).find((k) => `${k}.bpmn` in files);
+                if (named)
+                    return named;
+            }
+        }
+        catch { /* a malformed descriptor is not worth failing a compile over */ }
+    }
+    // No descriptor (a project scaffolded some other way): a sibling `caseplan.json`
+    // still says what the project ships, and only the output name is in doubt.
+    if (existsSync(join(dir, 'caseplan.json')))
+        return 'caseplan.json';
+    return basename(outPath);
+}
+/**
+ * Keep the sibling `entry-points.json` in step with the caseplan's trigger nodes:
+ * the runtime discovers triggers there, so a trigger node with no matching
+ * entry-point is invisible at deploy. One entry per profile-owned trigger
+ * node — preserving an existing entry's `uniqueId`, minting a *deterministic*
+ * one (so rebuilds stay byte-stable) for new triggers, and dropping orphans.
+ * No-op (returns -1) when there is no `entry-points.json` beside the output (e.g.
+ * a bare `serialize` outside a scaffolded project).
+ */
+function syncEntryPoints(caseplan, outPath) {
+    const epPath = join(dirname(outPath), 'entry-points.json');
+    if (!existsSync(epPath))
+        return -1;
+    const ep = JSON.parse(readFileSync(epPath, 'utf8'));
+    const existing = new Map((ep.entryPoints ?? []).map((e) => [String(e.filePath).split('#')[1] ?? '', e]));
+    const base = packagedCaseFileName(dirname(outPath), outPath);
+    const triggerNodes = caseplan.nodes.filter((n) => n[CASE_FORMAT_PROFILE.nodeTypeField] === CASE_FORMAT_PROFILE.triggerNodeType);
+    ep.entryPoints = triggerNodes.map((n) => {
+        const prev = existing.get(n.id);
+        // Project the case's In/Out args into this trigger's input/output schemas
+        // (In-args scoped to this trigger by elementId; Out-args to every entry).
+        const { input, output } = entryPointIO(caseplan.variables, n.id);
+        return {
+            filePath: `/content/${base}.bpmn#${n.id}`,
+            uniqueId: prev?.uniqueId ?? stableUuid(`entrypoint:${n.id}`),
+            type: 'CaseManagement',
+            input,
+            output,
+            displayName: (n.data && n.data.label) || n.id,
+        };
+    });
+    writeFileSync(epPath, JSON.stringify(ep, null, 2) + '\n');
+    return triggerNodes.length;
+}
+/**
+ * Keep a scaffolded project's solution-resource sidecar in step with the Case
+ * artifact. `resources refresh` reads bindings_v2.json, not caseplan.json, and
+ * succeeds with zero warnings when the sidecar is stale or empty.
+ *
+ * Non-connector resources come from root binding pairs and referenced tasks.
+ * Connector connection and folder bindings have different resource keys, so
+ * their relationship comes from the context[] that references both binding ids.
+ * No-op when compiling outside a scaffolded project.
+ */
+function syncBindingsV2(caseplan, outPath) {
+    const sidecarPath = join(dirname(outPath), 'bindings_v2.json');
+    if (!existsSync(sidecarPath))
+        return -1;
+    const bindings = Array.isArray(caseplan.bindings)
+        ? caseplan.bindings.filter(isRecord)
+        : [];
+    const byId = new Map(bindings
+        .filter((binding) => typeof binding.id === 'string')
+        .map((binding) => [binding.id, binding]));
+    const resources = [];
+    const grouped = new Map();
+    for (const binding of bindings) {
+        const resource = stringValue(binding.resource);
+        const key = stringValue(binding.resourceKey);
+        if (!resource || !key || resource.toLowerCase() === 'connection')
+            continue;
+        const groupKey = `${resource}\0${key}`;
+        let group = grouped.get(groupKey);
+        if (!group) {
+            group = { resource, key, value: {} };
+            grouped.set(groupKey, group);
+        }
+        const property = stringValue(binding.propertyAttribute) ?? stringValue(binding.name);
+        if (property)
+            group.value[property] = { defaultValue: binding.default ?? key };
+        const subType = stringValue(binding.resourceSubType);
+        if (subType)
+            group.subType = subType;
+    }
+    const referenceTaskSubTypes = new Map([
+        ['process', 'ProcessOrchestration'],
+        ['agent', 'Agent'],
+        ['rpa', undefined],
+        ['api-workflow', 'Api'],
+        ['case-management', 'CaseManagement'],
+        ['flow-process', 'ProcessOrchestration'],
+    ]);
+    const seenConnections = new Set();
+    const connectionResources = [];
+    visitRecords(caseplan, (record) => {
+        const type = stringValue(record.type);
+        const data = isRecord(record.data) ? record.data : undefined;
+        if (type && data && referenceTaskSubTypes.has(type)) {
+            const name = referencedBindingValue(data.name, byId);
+            const folderPath = referencedBindingValue(data.folderPath, byId);
+            if (name && folderPath) {
+                const key = referencedBindingResourceKey(data.name, byId)
+                    ?? referencedBindingResourceKey(data.folderPath, byId)
+                    ?? `${folderPath}.${name}`;
+                const groupKey = `process\0${key}`;
+                if (!grouped.has(groupKey)) {
+                    grouped.set(groupKey, {
+                        resource: 'process',
+                        key,
+                        value: {
+                            name: { defaultValue: name },
+                            folderPath: { defaultValue: folderPath },
+                        },
+                        subType: referenceTaskSubTypes.get(type),
+                    });
+                }
+            }
+        }
+        if (!Array.isArray(record.context))
+            return;
+        const context = new Map(record.context
+            .filter(isRecord)
+            .filter((row) => typeof row.name === 'string')
+            .map((row) => [row.name, row.value]));
+        const connector = stringValue(context.get('connectorKey'));
+        const connectionId = referencedBindingValue(context.get('connection'), byId);
+        const folderKey = referencedBindingValue(context.get('folderKey'), byId);
+        if (!connector || !connectionId || !folderKey || seenConnections.has(connectionId))
+            return;
+        seenConnections.add(connectionId);
+        connectionResources.push({
+            resource: 'Connection',
+            key: connectionId,
+            value: {
+                connectionId: { defaultValue: connectionId },
+                folderKey: { defaultValue: folderKey },
+            },
+            metadata: { connector },
+        });
+    });
+    for (const group of grouped.values()) {
+        resources.push({
+            resource: group.resource,
+            key: group.key,
+            value: group.value,
+            metadata: group.subType ? { subType: group.subType } : {},
+        });
+    }
+    resources.push(...connectionResources);
+    writeFileSync(sidecarPath, JSON.stringify({ version: '2.0', resources }, null, 2) + '\n');
+    return resources.length;
+}
+function referencedBindingValue(value, bindings) {
+    const ref = stringValue(value);
+    if (!ref)
+        return undefined;
+    if (!ref.startsWith('=bindings.'))
+        return ref;
+    const binding = bindings.get(ref.slice('=bindings.'.length));
+    return binding && (stringValue(binding.default) ?? stringValue(binding.resourceKey));
+}
+function referencedBindingResourceKey(value, bindings) {
+    const ref = stringValue(value);
+    if (!ref?.startsWith('=bindings.'))
+        return undefined;
+    return stringValue(bindings.get(ref.slice('=bindings.'.length))?.resourceKey);
+}
+function visitRecords(value, visit) {
+    if (Array.isArray(value)) {
+        for (const item of value)
+            visitRecords(item, visit);
+        return;
+    }
+    if (!isRecord(value))
+        return;
+    visit(value);
+    for (const child of Object.values(value))
+        visitRecords(child, visit);
+}
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function stringValue(value) {
+    return typeof value === 'string' && value.length > 0 ? value : undefined;
+}
+/** A deterministic UUID-shaped id (not a real v4 — the schema only needs a stable string). */
+function stableUuid(seed) {
+    const h = createHash('sha256').update(seed).digest('hex');
+    return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20, 32)}`;
+}
+runWhenInvokedDirectly(import.meta.url, 'compile', run);

package/dist/case/decompile-cli.d.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import { type CliExitCode } from '../cli-run.js';
+/**
+ * `run(argv)` is the tool contract the family-first `flow-sdk` CLI loads
+ * (`cli/common.ts` → `invoke`). It must NOT read `process.argv` — under the
+ * unified CLI that still holds `case decompile …`, so the positional scan would
+ * pick up the family word. Errors throw; both callers report and set exit 1.
+ */
+export declare function run(argv: string[]): CliExitCode;

package/dist/case/decompile-cli.js

@@ -0,0 +1,117 @@
+#!/usr/bin/env node
+/**
+ * decompile-cli — caseplan.json → <Name>.case.ts
+ *
+ * Usage:
+ *   node --experimental-strip-types decompile-cli.js <caseplan.json> [-o Name.case.ts] [--import <specifier>] [--library <dir>] [--best-effort] [--no-pipeline]
+ *
+ * The reverse of compile-cli: reads a V20-V30 caseplan and emits builder source whose
+ * default export re-serializes to the same caseplan (structurally). `--import`
+ * sets the module specifier of the emitted `import { casePlan, rule }` line
+ * (default the package's `./case` subpath export) so the
+ * emitted file resolves for a package consumer. The library default
+ * (`decompile()` in decompile.js) stays repo-relative for in-tree callers —
+ * mirroring how the Flow arm's decompile-cli overrides it. By default the
+ * command also emits a `<Name>.pipeline.mjs` helper that recompiles edits
+ * through the public Case CLI. Pass `--no-pipeline` to skip it.
+ */
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { resolveLibraryDir } from '../registry/cache.js';
+import { basename, resolve } from 'node:path';
+import { runWhenInvokedDirectly } from '../cli-run.js';
+import { Library } from '../core/library.js';
+import { decompileWithDiagnostics } from './decompile.js';
+import { CASE_IMPORT } from '../package-name.js';
+function opt(argv, name) {
+    const i = argv.indexOf(name);
+    return i >= 0 ? argv[i + 1] : undefined;
+}
+/** Derive a PascalCase base name from the case name for the default output file. */
+function baseName(plan) {
+    const src = plan.name ?? plan.id ?? 'Case';
+    const pascal = src
+        .split(/[^A-Za-z0-9]+/)
+        .filter(Boolean)
+        .map((w) => w[0].toUpperCase() + w.slice(1))
+        .join('');
+    return pascal || 'Case';
+}
+/**
+ * `run(argv)` is the tool contract the family-first `flow-sdk` CLI loads
+ * (`cli/common.ts` → `invoke`). It must NOT read `process.argv` — under the
+ * unified CLI that still holds `case decompile …`, so the positional scan would
+ * pick up the family word. Errors throw; both callers report and set exit 1.
+ */
+export function run(argv) {
+    if (argv.length === 0 || argv[0] === '-h' || argv[0] === '--help') {
+        console.error('usage: decompile <caseplan.json> [-o Name.case.ts] [--import <specifier>] [--library <dir>] [--best-effort] [--no-pipeline]');
+        return 2;
+    }
+    const flags = new Set(['-o', '--import', '--library']);
+    const pos = argv.find((a, i) => !flags.has(a) && !flags.has(argv[i - 1]) && !a.startsWith('-'));
+    if (!pos) {
+        console.error('decompile: missing <caseplan.json>');
+        return 2;
+    }
+    const plan = JSON.parse(readFileSync(pos, 'utf8'));
+    const libraryDir = resolveLibraryDir(opt(argv, '--library'));
+    const library = libraryDir && existsSync(`${libraryDir}/index.json`) ? new Library(libraryDir) : undefined;
+    const importSpecifier = opt(argv, '--import') ?? CASE_IMPORT;
+    const bestEffort = argv.includes('--best-effort');
+    const result = decompileWithDiagnostics(plan, {
+        importSpecifier,
+        library,
+        bestEffort,
+    });
+    const out = opt(argv, '-o') ?? `${baseName(plan)}.case.ts`;
+    writeFileSync(out, result.source);
+    console.log(`decompile: wrote ${basename(out)}`);
+    for (const diagnostic of result.diagnostics) {
+        console.error(`decompile: [${diagnostic.code}] ${diagnostic.location}: ${diagnostic.message}`);
+    }
+    if (!argv.includes('--no-pipeline')) {
+        const pipelinePath = out.replace(/\.case\.ts$|\.ts$/, '') + '.pipeline.mjs';
+        writeFileSync(pipelinePath, pipelineScript(resolve(pos), resolve(out), importSpecifier, bestEffort, libraryDir ? resolve(libraryDir) : undefined));
+        console.log(`decompile: wrote ${basename(pipelinePath)}`);
+    }
+    return 0;
+}
+/**
+ * Case preserves its non-authoring lanes in the generated source, so unlike
+ * Flow it needs no three-way merge. The wrapper recompiles that source while
+ * feeding the original caseplan back as the binding registry; this preserves
+ * the resource keys that the typed source deliberately names symbolically.
+ */
+function pipelineScript(originalPath, tsPath, importSpecifier, bestEffort, libraryDir) {
+    const base = tsPath.replace(/\.case\.ts$|\.ts$/, '');
+    return `#!/usr/bin/env node
+// Generated by case decompile — edit ${basename(tsPath)}, then run this file.
+import { execFileSync, spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+
+const ORIGINAL = ${JSON.stringify(originalPath)};
+const TS       = ${JSON.stringify(tsPath)};
+const OUTPUT   = ${JSON.stringify(base + '.caseplan.json')};
+const IMPORT   = ${JSON.stringify(importSpecifier)};
+const LIBRARY  = ${JSON.stringify(libraryDir)};
+const BEST_EFFORT = ${JSON.stringify(bestEffort)};
+
+const uipProbe = spawnSync('uip', ['maestro', 'case', 'compile', '--help'], { stdio: 'ignore' });
+const frontDoor = !uipProbe.error && uipProbe.status === 0
+  ? { file: 'uip', prefix: ['maestro', 'case'] }
+  : { file: 'npx', prefix: ['--no-install', 'flow-sdk', 'case'] };
+const run = (verb, args) =>
+  execFileSync(frontDoor.file, [...frontDoor.prefix, verb, ...args], { stdio: 'inherit' });
+const withLibrary = (args) => LIBRARY ? [...args, '--library', LIBRARY] : args;
+
+if (!existsSync(TS)) {
+  const decompileArgs = [ORIGINAL, '-o', TS, '--import', IMPORT, '--no-pipeline'];
+  if (BEST_EFFORT) decompileArgs.push('--best-effort');
+  run('decompile', withLibrary(decompileArgs));
+}
+
+run('compile', withLibrary([TS, '-o', OUTPUT, '--bindings', ORIGINAL]));
+console.log('\\n>>> Wrote ' + ${JSON.stringify(base + '.caseplan.json')});
+`;
+}
+runWhenInvokedDirectly(import.meta.url, 'case-decompile', run);

package/dist/case/decompile.d.ts

@@ -0,0 +1,187 @@
+/**
+ * case/decompile — invert an authorable Case JSON document into fluent builder
+ * source. At the SDK write floor, compiling the generated source reproduces the
+ * input bytes; platform-owned preservation lanes are handled separately.
+ */
+import type { Library } from '../core/library.js';
+interface IoRow {
+    id?: string;
+    name?: string;
+    type?: string;
+    default?: unknown;
+    body?: unknown;
+    _jsonSchema?: unknown;
+    custom?: boolean;
+    elementId?: string;
+    var?: string;
+    source?: string;
+    value?: unknown;
+    target?: string;
+    subType?: string;
+    displayName?: string;
+    required?: unknown;
+    options?: unknown;
+}
+interface SubscriptionBag {
+    serviceType?: string;
+    context?: IoRow[];
+    inputs?: unknown[];
+    outputs?: IoRow[];
+    bindings?: unknown[];
+    [key: string]: unknown;
+}
+interface Rule {
+    rule: string;
+    id?: string;
+    selectedStageId?: string;
+    selectedStageIds?: string[];
+    selectedTasksIds?: string[];
+    conditionExpression?: string;
+    uipath?: SubscriptionBag;
+    slaId?: string;
+    escalationId?: string;
+}
+interface Condition {
+    id?: string;
+    displayName?: string;
+    rules?: Rule[][];
+    isInterrupting?: boolean;
+    marksStageComplete?: boolean;
+    type?: string;
+    exitToStageId?: string;
+    marksCaseComplete?: boolean;
+}
+interface EscalationWire {
+    id?: string;
+    displayName?: string;
+    triggerInfo?: {
+        type?: string;
+        atRiskPercentage?: number;
+    };
+    action?: {
+        type?: string;
+        recipients?: Array<{
+            scope?: string;
+            target?: string;
+            value?: string;
+        }>;
+    };
+}
+interface SlaWire {
+    id?: string;
+    displayName?: string;
+    expression?: string;
+    count?: number;
+    unit?: string;
+    escalationRule?: EscalationWire[];
+}
+interface TaskNode {
+    id?: string;
+    displayName?: string;
+    type: string;
+    data?: Record<string, any>;
+    shouldRunOnlyOnce?: boolean;
+    isRequired?: boolean;
+    skipCondition?: string;
+    description?: string;
+    entryConditions?: Condition[];
+    conditions?: unknown;
+    nonSequentialRunConditions?: unknown;
+    [key: string]: unknown;
+}
+interface StageNode {
+    id?: string;
+    type: string;
+    stageType?: string;
+    data?: {
+        label?: string;
+        description?: string;
+        isRequired?: boolean;
+        tasks?: TaskNode[][];
+        entryConditions?: Condition[];
+        exitConditions?: Condition[];
+        slaRules?: SlaWire[];
+        adhocOrchestrationData?: unknown;
+        [key: string]: unknown;
+    };
+    position?: unknown;
+}
+interface TriggerNode {
+    id?: string;
+    type: string;
+    data?: Record<string, any>;
+}
+interface VarEntry extends IoRow {
+    name: string;
+    type: string;
+}
+interface BindingEntry {
+    id?: string;
+    resourceKey?: string;
+    default?: string;
+}
+interface CasePlan {
+    id?: string;
+    name?: string;
+    description?: string;
+    version?: string;
+    bindings?: BindingEntry[];
+    variables?: {
+        inputs?: VarEntry[];
+        outputs?: VarEntry[];
+        inputOutputs?: VarEntry[];
+    };
+    metadata?: {
+        caseIdentifier?: string;
+        caseIdentifierType?: 'constant' | 'external';
+        caseAppEnabled?: boolean;
+        caseExitRules?: Condition[];
+        slaRules?: SlaWire[];
+        caseAppConfig?: {
+            caseSummary?: unknown;
+            sections?: Array<{
+                id?: unknown;
+                title?: unknown;
+                details?: unknown;
+                error?: unknown;
+                titleError?: unknown;
+                [key: string]: unknown;
+            }>;
+            stageOrder?: unknown;
+            hiddenStageIds?: unknown;
+            [key: string]: unknown;
+        };
+        adhocCaseEndData?: unknown;
+        allowAdhocOptionalStageTasks?: unknown;
+        waitForHumanSelectNextStageDFConnector?: unknown;
+        [key: string]: unknown;
+    };
+    nodes?: Array<StageNode | TriggerNode | Record<string, any>>;
+    edges?: unknown[];
+    layout?: unknown;
+    [key: string]: unknown;
+}
+export interface DecompileOptions {
+    /** Module specifier for the generated authoring import. */
+    importSpecifier?: string;
+    /** Connector library used to recover symbolic `.connector(key, action, …)`. */
+    library?: Library;
+    /**
+     * Emit an intentionally non-buildable repair scaffold for unsupported task
+     * kinds and unresolved task/stage references instead of stopping at the first
+     * one. Strict fidelity remains the default.
+     */
+    bestEffort?: boolean;
+}
+export interface CaseDecompileDiagnostic {
+    code: 'UNSUPPORTED_TASK_KIND' | 'UNKNOWN_STAGE_REFERENCE' | 'UNKNOWN_TASK_REFERENCE' | 'UNKNOWN_EXIT_TARGET';
+    message: string;
+    location: string;
+}
+export interface CaseDecompileResult {
+    source: string;
+    diagnostics: CaseDecompileDiagnostic[];
+}
+export declare function decompileWithDiagnostics(plan: CasePlan, options?: DecompileOptions): CaseDecompileResult;
+export declare function decompile(plan: CasePlan, options?: DecompileOptions): string;
+export {};