@uipath/maestro-builder-sdk 5.2.0

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

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { type CliExitCode } from '../cli-run.js';
+export declare function run(argv: string[]): Promise<CliExitCode>;

package/dist/case/check-cli.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+/**
+ * check-cli — fast static validation of <Name>.case.ts (no output file).
+ *
+ * Usage: node --experimental-strip-types check-cli.js <case.ts | BaseName>
+ * Exits 0 when clean (warnings allowed), 1 on any error.
+ */
+import { resolveCaseFile, loadBuiltCase } from './load.js';
+import { check } from './check.js';
+import { runWhenInvokedDirectly } from '../cli-run.js';
+import { ensureTypeScriptRuntime } from '../node-runtime.js';
+export async function run(argv) {
+    if (argv.length === 0 || argv[0] === '-h' || argv[0] === '--help') {
+        console.error('usage: check <case.ts | BaseName>');
+        return 2;
+    }
+    const file = resolveCaseFile(argv[0]);
+    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(`check: ${errors.length} error(s).`);
+        return 1;
+    }
+    console.log(`check: OK${diags.length ? ` (${diags.length} warning(s))` : ''}`);
+    return 0;
+}
+runWhenInvokedDirectly(import.meta.url, 'check', run);

package/dist/case/check.d.ts

@@ -0,0 +1,18 @@
+/**
+ * case/check — fast static validation of a BuiltCase before serialization.
+ *
+ * Surfaces the common `uip maestro case validate` failures early (task without
+ * an entry rule, case/stage without a completion rule, an unsatisfiable
+ * `required-tasks-completed`, unresolved stage/task references, duplicate stage
+ * labels) so authoring gets instant feedback. The authoritative gate is still
+ * `uip maestro case validate` / `@uipath/case-schema` on the emitted file.
+ */
+import type { BuiltCase } from './case-sdk.js';
+export interface Diagnostic {
+    level: 'error' | 'warning';
+    code: string;
+    message: string;
+    where?: string;
+    suggestion?: string;
+}
+export declare function check(built: BuiltCase): Diagnostic[];

package/dist/case/check.js

@@ -0,0 +1,456 @@
+import { types } from '../core/expr.js';
+import { authoredCaseVersion, CASE_FORMAT_PROFILE, CASE_SCHEMA_VERSIONS } from './format-profile.js';
+import { schemaVersionRefusal } from '../schema-version.js';
+import { caseJsonPreservation, caseJsonPreservationErrors } from './preserve.js';
+const TYPE_NAMES = new Set(Object.values(types));
+// audit-case-coverage: rule-slot table start
+// This runtime table must equal the committed matrix's rejected cells. The audit
+// parses these object literals; the product-pin matrix currently rejects none.
+const ILLEGAL = [];
+// audit-case-coverage: rule-slot table end
+export function check(built) {
+    const diags = [];
+    for (const message of caseJsonPreservationErrors(caseJsonPreservation(built)))
+        diags.push({
+            level: 'error',
+            code: 'PRESERVATION_COLLISION',
+            message: `Invalid Case JSON preservation payload: ${message}.`,
+        });
+    if (!built.id)
+        diags.push({ level: 'error', code: 'NO_ID', message: 'casePlan() requires an id.' });
+    const requestedVersion = authoredCaseVersion(built);
+    if (requestedVersion !== undefined) {
+        diags.push({
+            level: 'warning',
+            code: 'VERSION_DEPRECATED',
+            message: `.version(${JSON.stringify(requestedVersion)}) is deprecated: the Case JSON schema version is declared with .schemaVersion(), which accepts only versions this build can write. This SDK writes ${CASE_FORMAT_PROFILE.writeVersion}.`,
+        });
+        if (requestedVersion !== CASE_FORMAT_PROFILE.writeVersion)
+            diags.push({
+                level: 'error',
+                code: 'VERSION_MISMATCH',
+                message: `.version(${JSON.stringify(requestedVersion)}) does not match the serializer's ${CASE_FORMAT_PROFILE.writeVersion} format profile. A document version is a grammar claim, not an author release value.`,
+            });
+    }
+    // The DECLARED grammar version (`.schemaVersion()`), as opposed to the
+    // deprecated `.version()` above. It is already refused at the call, so this
+    // only fires for a BuiltCase assembled by hand — which `serialize()` would
+    // then throw on, so reporting it first is what makes the message actionable.
+    const schemaRefusal = schemaVersionRefusal(CASE_SCHEMA_VERSIONS, built.version);
+    if (schemaRefusal)
+        diags.push({ level: 'error', code: 'SCHEMA_VERSION_UNSUPPORTED', message: schemaRefusal });
+    const checkName = (kind, name, where) => {
+        if (/[:.]/.test(name))
+            diags.push({
+                level: 'error',
+                code: 'NAME_HYGIENE',
+                message: `${kind} "${name}" contains ":" or ".". Runtime event keys do not escape these characters, so instance state can silently corrupt; rename it without either character.`,
+                where,
+            });
+    };
+    checkName('Case name', built.name, built.name);
+    for (const [index, section] of (built.caseAppConfig?.sections ?? []).entries()) {
+        const where = `Case App section "${section.title || index + 1}"`;
+        const details = section.details;
+        if (!details || typeof details !== 'object' || Array.isArray(details)) {
+            diags.push({
+                level: 'error',
+                code: 'CASE_APP_DETAILS_TYPE',
+                message: `${where} details must be a map of primitive values.`,
+                where,
+            });
+            continue;
+        }
+        const entries = Object.entries(details);
+        if (entries.length > 6)
+            diags.push({
+                level: 'error',
+                code: 'CASE_APP_DETAILS_LIMIT',
+                message: `${where} has ${entries.length} details; Case App sections support at most 6.`,
+                where,
+            });
+        const nested = entries.find(([, value]) => value !== null && !['string', 'number', 'boolean'].includes(typeof value));
+        if (nested)
+            diags.push({
+                level: 'error',
+                code: 'CASE_APP_DETAILS_TYPE',
+                message: `${where} detail "${nested[0]}" must be a string, number, boolean, or null; nested objects and arrays are not supported.`,
+                where,
+            });
+    }
+    const stageLabels = new Set();
+    const taskNames = new Set();
+    let selectNextStageCount = 0;
+    for (const stage of built.stages) {
+        checkName('Stage label', stage.label, stage.label);
+        if (stageLabels.has(stage.label))
+            diags.push({ level: 'error', code: 'DUP_STAGE', message: `Duplicate stage label "${stage.label}".`, where: stage.label });
+        stageLabels.add(stage.label);
+        for (const exit of stage.exit) {
+            if (!exit.selectNextStage)
+                continue;
+            selectNextStageCount += 1;
+            if (exit.type !== 'wait-for-user')
+                diags.push({
+                    level: 'error',
+                    code: 'SELECT_NEXT_STAGE_EXIT_TYPE',
+                    message: `Stage "${stage.label}" configures selectNextStage on an exit that is not type "wait-for-user".`,
+                    where: stage.label,
+                });
+            if (!exit.selectNextStage.objectName.trim())
+                diags.push({
+                    level: 'error',
+                    code: 'SELECT_NEXT_STAGE_OBJECT_NAME',
+                    message: `Stage "${stage.label}" selectNextStage.objectName must name a Data Fabric entity.`,
+                    where: stage.label,
+                });
+        }
+        for (const lane of stage.lanes)
+            for (const t of lane) {
+                // Task displayNames must be unique across the case: the platform rejects
+                // duplicates (CRITICAL), and a bare selected-tasks-completed reference
+                // would silently mis-resolve to the first task of that name.
+                if (taskNames.has(t.name))
+                    diags.push({
+                        level: 'error',
+                        code: 'DUP_TASK',
+                        message: `Duplicate task displayName "${t.name}" — task names must be unique across the case.`,
+                        where: `${stage.label}/${t.name}`,
+                    });
+                taskNames.add(t.name);
+                // Also register the qualified `Stage/Task` key so a qualified reference resolves.
+                taskNames.add(`${stage.label}/${t.name}`);
+            }
+    }
+    // Condition `displayName`s must be unique across the whole case — `uip maestro
+    // case validate` rejects a repeat as CASE_MGMT_RULE_NAME_DUPLICATE, at error
+    // severity. The namespace spans stage entry, stage exit and task entry
+    // conditions plus `metadata.caseExitRules`, in every combination (probed
+    // against case-schema 0.1016.2).
+    //
+    // …EXCEPT that the validator ignores the names the DESIGNER generates, so a
+    // case built in Studio Web can repeat them freely. That allowlist is why the
+    // old SDK defaults failed: `Entry rule` sat one token short of the exempt
+    // `Entry rule <n>` family, and `Complete rule` was never in it at all.
+    // Mirroring the allowlist here is what keeps this diagnostic from contradicting
+    // the validator on a decompiled brownfield file — CMGoldenExpense legitimately
+    // carries 18 conditions named "Entry rule 1" and validates clean.
+    //
+    // Over-exempting is the safe direction: a name wrongly treated as exempt is
+    // still caught downstream by `validate`, whereas a false positive here would
+    // be noise on a document the platform accepts.
+    //
+    // WARNING, not error, because an error GATES EMISSION and the duplicates that
+    // reach this code are overwhelmingly brownfield: real V27/V30 documents the
+    // platform itself produced carry them (the LinearThreeStages migration oracle
+    // repeats "Entry Rule 1" six times). Refusing to compile those would turn the
+    // decompile → edit → recompile loop into a hard stop for anyone whose existing
+    // case has duplicate names — over a defect they did not introduce and this
+    // edit is not about. `validate` remains the authoritative gate and still
+    // reports it as an error.
+    const DESIGNER_GENERATED = /^(?:(?:Entry|Exit|Completion) rule \d+|Case complete|Stage complete|Tasks completed rule)$/;
+    // `serialize` de-duplicates the defaults it generates, so anything reported
+    // here is a name the author spelled out twice; renaming it for them would be
+    // the worse surprise, and without this the collision only surfaces one step
+    // later, from `validate`, after a compile.
+    const conditionNames = new Map();
+    const checkConditionName = (displayName, where) => {
+        if (!displayName || DESIGNER_GENERATED.test(displayName))
+            return;
+        const first = conditionNames.get(displayName);
+        if (first !== undefined)
+            diags.push({
+                level: 'warning',
+                code: 'DUP_RULE_NAME',
+                message: `Rule name "${displayName}" is not unique — also used by ${first}. `
+                    + '`uip maestro case validate` rejects this as CASE_MGMT_RULE_NAME_DUPLICATE; rename one of them.',
+                where,
+            });
+        else
+            conditionNames.set(displayName, where);
+    };
+    for (const [i, c] of built.caseExit.entries())
+        checkConditionName(c.displayName, `case exit condition ${i + 1}`);
+    for (const stage of built.stages) {
+        for (const c of stage.entry)
+            checkConditionName(c.displayName, `stage "${stage.label}" entry`);
+        for (const c of stage.exit)
+            checkConditionName(c.displayName, `stage "${stage.label}" exit`);
+        for (const lane of stage.lanes)
+            for (const task of lane)
+                for (const c of task.entry)
+                    checkConditionName(c.displayName, `task "${task.name}" entry`);
+    }
+    if (selectNextStageCount > 1)
+        diags.push({
+            level: 'error',
+            code: 'SELECT_NEXT_STAGE_MULTIPLE',
+            message: 'A case can configure selectNextStage on at most one exit because the wire contract has one case-level connector.',
+        });
+    if (built.stages.length === 0)
+        diags.push({ level: 'error', code: 'NO_STAGES', message: 'Case has no stages.' });
+    const hasCompletion = built.caseExit.some((c) => c.marksCaseComplete !== false);
+    if (!hasCompletion)
+        diags.push({
+            level: 'error',
+            code: 'NO_CASE_COMPLETION',
+            message: 'Case has no completion rule — add .completeWhen(rule(\'required-stages-completed\')).',
+        });
+    const refPlacement = (r, slot, where) => {
+        const bad = ILLEGAL.find((x) => x.rule === r.rule && x.slot === slot);
+        if (bad)
+            diags.push({
+                level: 'error',
+                code: 'RULE_PLACEMENT',
+                message: `Rule "${r.rule}" is not legal at ${slot} — ${bad.why}.`,
+                where,
+            });
+    };
+    const refStage = (r, where) => {
+        if ((r.rule === 'selected-stage-completed' || r.rule === 'selected-stage-exited')) {
+            if (!r.stage || !stageLabels.has(r.stage))
+                diags.push({ level: 'error', code: 'UNKNOWN_STAGE_REF', message: `Rule "${r.rule}" references unknown stage "${r.stage}".`, where });
+        }
+        if (r.rule === 'selected-tasks-completed') {
+            if (!r.tasks?.length && !r.expression)
+                diags.push({
+                    level: 'warning',
+                    code: 'RULE_TASKS_REQUIRED',
+                    message: 'Rule "selected-tasks-completed" has neither selected tasks nor an expression gate — pass { tasks: [...] } or use when(expression).',
+                    where,
+                });
+            for (const n of r.tasks ?? [])
+                if (!taskNames.has(n))
+                    diags.push({ level: 'error', code: 'UNKNOWN_TASK_REF', message: `Rule "selected-tasks-completed" references unknown task "${n}".`, where });
+        }
+    };
+    // ── `=js:vars.<name>` resolvability — REMOVED, superseded by #257 ───────────
+    // This file briefly carried a VAR_NOT_REFERENCEABLE error asserting that only a
+    // trigger-bound In-arg (`.input(shape, { from })`) could be read as `=js:vars.x`,
+    // and that a bare `.var()` always failed `uip maestro case validate` with
+    // "Variable 'vars.x' does not exist". That was empirically true when written and
+    // is now FALSE: #257 fixed the serializer to emit the `inputOutputs` companion
+    // with `id: <name>` / `elementId: "root"`, which is what the platform resolves
+    // `vars.<name>` against — so a declared `.var()` is readable.
+    //
+    // Both halves of the old rule are superseded:
+    //   - "declared vars are unreadable"  -> no longer true (#257 serializer fix).
+    //   - "undeclared vars.x slips through" -> #257 also added a strict namespace
+    //     check to CaseBuilder.build(), which throws CaseBuildError with a
+    //     near-miss suggestion before check() ever runs.
+    // Re-adding any variable-reachability rule here would reintroduce a false
+    // positive that blocks emit (this gate runs before serialization), so it must be
+    // re-derived from the serializer rather than from remembered probe results.
+    for (const stage of built.stages) {
+        checkStage(stage, diags, refStage, refPlacement);
+        stage.slaRules.forEach((s, i) => checkSla(s, `stage "${stage.label}" SLA #${i + 1}`, diags));
+    }
+    built.slaRules.forEach((s, i) => checkSla(s, `case SLA #${i + 1}`, diags));
+    for (const c of built.caseExit)
+        for (const g of c.rules)
+            for (const r of g) {
+                refStage(r, 'case-exit');
+                refPlacement(r, 'case-exit', 'case-exit');
+            }
+    return diags;
+}
+/**
+ * SLA guardrails surfaced early: zero at-risk percentages that the engine
+ * coerces to 100, empty recipient lists, and deadlines with no escalations.
+ */
+function checkSla(sla, where, diags) {
+    if (sla.count < 0 || sla.count > 1000)
+        diags.push({
+            level: 'error',
+            code: 'SLA_COUNT_RANGE',
+            message: `${where} has count ${sla.count}; SLA count must be between 0 and 1000 inclusive (engine error 400019).`,
+            where,
+        });
+    else if (sla.count === 0)
+        diags.push({ level: 'warning', code: 'SLA_NONPOSITIVE', message: `${where} has a zero-length deadline (count 0).`, where });
+    if (sla.escalations.length === 0) {
+        diags.push({ level: 'warning', code: 'SLA_NO_ESCALATIONS', message: `${where} has no escalations — the deadline notifies no one.`, where });
+        return;
+    }
+    for (const e of sla.escalations) {
+        if (e.trigger === 'at-risk' && e.atRiskPercentage === 0)
+            diags.push({
+                level: 'warning',
+                code: 'ESCALATION_ZERO_ATRISK_PCT',
+                message: `${where}: an 'at-risk' escalation sets atRiskPercentage to 0, but the engine silently treats 0 as 100.`,
+                where,
+            });
+        if (e.notify.length === 0)
+            diags.push({ level: 'warning', code: 'ESCALATION_NO_RECIPIENTS', message: `${where}: an escalation notifies no one (empty notify).`, where });
+    }
+}
+function isNilOrEmpty(value) {
+    if (value === undefined || value === null)
+        return true;
+    if (typeof value === 'string' || Array.isArray(value))
+        return value.length === 0;
+    if (typeof value === 'object')
+        return Object.keys(value).length === 0;
+    return false;
+}
+function checkStage(stage, diags, refStage, refPlacement) {
+    const where = `stage "${stage.label}"`;
+    if (stage.exception && stage.required !== false)
+        diags.push({
+            level: 'warning',
+            code: 'EXCEPTION_STAGE_REQUIRED',
+            message: `${where} is a secondary stage and should be explicitly non-required — add .required(false) so it does not gate required-stages-completed.`,
+            where: stage.label,
+        });
+    for (const c of stage.entry)
+        for (const g of c.rules)
+            for (const r of g) {
+                refStage(r, where);
+                refPlacement(r, 'stage-entry', where);
+            }
+    for (const c of stage.exit)
+        for (const g of c.rules)
+            for (const r of g) {
+                refStage(r, where);
+                refPlacement(r, 'stage-exit', where);
+            }
+    for (const lane of stage.lanes)
+        for (const task of lane)
+            for (const c of task.entry)
+                for (const g of c.rules)
+                    for (const r of g)
+                        refPlacement(r, 'task-entry', `task "${task.name}" in ${where}`);
+    // Two exits whose rule sets are IDENTICAL collide: `uip maestro case validate`
+    // rejects the stage with "duplicate exit rules". Verified — and verified in the
+    // other direction too, because the obvious guess is wrong: exits sharing a rule
+    // TYPE are fine as long as something distinguishes them. Both of these are Valid:
+    //   .exitWhen(rule('required-tasks-completed', { expression: '=js:v < 25000' }), …)
+    //   .exitWhen(rule('required-tasks-completed', { expression: '=js:v >= 25000' }), …)
+    // (3-way with distinct expressions is Valid as well). Only a literal duplicate
+    // fails. So the signature below must include the expression and the refs, not
+    // just the rule name — keying on the rule type alone would reject legal
+    // value-tiered routing, which is the natural way to express "under $25k goes here".
+    const sig = (c) => JSON.stringify(c.rules.map((g) => g.map((r) => [r.rule, r.stage ?? '', (r.tasks ?? []).join(','), r.expression ?? ''])));
+    const seenExit = new Map();
+    stage.exit.forEach((c, i) => {
+        const k = sig(c);
+        const first = seenExit.get(k);
+        if (first !== undefined)
+            diags.push({
+                level: 'error',
+                code: 'DUP_EXIT_RULE',
+                message: `${where} has two exits (#${first + 1} and #${i + 1}) with identical rules — ` +
+                    `\`uip maestro case validate\` rejects this with "duplicate exit rules". ` +
+                    `Distinguish them with an \`expression\` (e.g. \`rule('required-tasks-completed', { expression: '=js:vars.x < 100' })\`), ` +
+                    `or give each outcome its own task and gate on \`selected-tasks-completed\`.`,
+                where: stage.label,
+            });
+        else
+            seenExit.set(k, i);
+    });
+    const marksComplete = stage.exit.some((c) => c.marksStageComplete);
+    if (!marksComplete && !stage.exception)
+        diags.push({ level: 'warning', code: 'STAGE_NO_COMPLETION', message: `${where} has no exit rule marking it complete.`, where: stage.label });
+    const tasks = stage.lanes.flat();
+    const anyRequired = tasks.some((t) => t.required);
+    const usesRequiredTasks = stage.exit.some((c) => c.rules.some((g) => g.some((r) => r.rule === 'required-tasks-completed')));
+    if (usesRequiredTasks && tasks.length > 0 && !anyRequired)
+        diags.push({
+            level: 'warning',
+            code: 'NO_REQUIRED_TASK',
+            message: `${where} exits on 'required-tasks-completed' but no task is marked .required().`,
+            where: stage.label,
+        });
+    for (const t of tasks) {
+        if (t.kind === 'wait-for-timer') {
+            const timerValues = [t.timer?.duration, t.timer?.date, t.timer?.cycle]
+                .filter((value) => typeof value === 'string' && value.trim().length > 0);
+            if (timerValues.length !== 1)
+                diags.push({
+                    level: 'error',
+                    code: 'TIMER_VALUE_REQUIRED',
+                    message: `Timer task "${t.name}" needs exactly one non-empty duration, date, or cycle. For a validating stand-in, use .waitForTimer({ duration: 'PT1M' }).`,
+                    where: t.name,
+                });
+        }
+        const invalidBinding = [...(t.inputs ?? []), ...(t.outputs ?? [])]
+            .find((binding) => !TYPE_NAMES.has(binding.type));
+        if (invalidBinding)
+            diags.push({
+                level: 'error',
+                code: 'TASK_IO_TYPE',
+                message: `Task "${t.name}" binding "${'var' in invalidBinding ? invalidBinding.var : invalidBinding.name}" has unsupported type ${JSON.stringify(invalidBinding.type)}. Use a type name such as "string" or "jsonSchema"; jsonSchema(...) is only for declaring a structured case variable.`,
+                where: t.name,
+            });
+        if (t.kind === 'flow-process' && (!t.ref || !t.ref.name.trim()))
+            diags.push({
+                level: 'error',
+                code: 'FLOW_PROCESS_EMPTY_DATA',
+                message: `Flow Process task "${t.name}" must name a published Flow; an empty reference degrades to a runtime no-op placeholder.`,
+                where: t.name,
+            });
+        if (t.kind === 'external-agent' || t.kind === 'external-workflow') {
+            const family = t.kind === 'external-agent' ? 'External Agent' : 'External Workflow';
+            if (!t.external)
+                diags.push({
+                    level: 'error',
+                    code: 'EXTERNAL_TASK_EMPTY_DATA',
+                    message: `${family} task "${t.name}" has no configuration; empty data degrades to a runtime no-op placeholder.`,
+                    where: t.name,
+                });
+            else {
+                if (t.external.mode !== 'sync' && t.external.mode !== 'async')
+                    diags.push({
+                        level: 'error',
+                        code: 'EXTERNAL_TASK_MODE',
+                        message: `${family} task "${t.name}" mode must be "sync" or "async"; no other service type is valid.`,
+                        where: t.name,
+                    });
+                if (!t.external.connector?.key?.trim() || !t.external.connector?.action?.trim())
+                    diags.push({
+                        level: 'error',
+                        code: 'EXTERNAL_TASK_DESCRIPTOR',
+                        message: `${family} task "${t.name}" requires a generated Integration Service descriptor.`,
+                        where: t.name,
+                    });
+                if (!t.external.connector?.connection?.trim())
+                    diags.push({
+                        level: 'error',
+                        code: 'EXTERNAL_TASK_CONNECTION',
+                        message: `${family} task "${t.name}" requires a non-empty connection binding name.`,
+                        where: t.name,
+                    });
+                if (!t.external.connector?.folder?.trim())
+                    diags.push({
+                        level: 'error',
+                        code: 'EXTERNAL_TASK_FOLDER',
+                        message: `${family} task "${t.name}" requires a non-empty folder binding name.`,
+                        where: t.name,
+                    });
+            }
+        }
+        if (stage.exception && t.runOnce !== undefined)
+            diags.push({
+                level: 'warning',
+                code: 'TASK_REENTRY_IGNORED',
+                message: `Task "${t.name}" in ${where} sets a run-once/re-entry option, but secondary stages ignore it. Remove .runOnce()/.runOnReEntry().`,
+                where: t.name,
+            });
+        const emptyRequiredField = [...(t.action?.inputs ?? []), ...(t.action?.outputs ?? [])]
+            .find((field) => field.required && isNilOrEmpty(field.value));
+        if (emptyRequiredField)
+            diags.push({
+                level: 'error',
+                code: 'EMPTY_REQUIRED_FIELD',
+                message: `Action field "${emptyRequiredField.name}" in task "${t.name}" is required but has no value. Set its value or remove required: true; required does not mean reviewer-must-fill.`,
+                where: t.name,
+            });
+        if (t.entry.length === 0)
+            diags.push({
+                level: 'error',
+                code: 'TASK_NO_ENTRY',
+                message: `Task "${t.name}" in ${where} has no entry rule — add .entryWhen(rule('current-stage-entered')).`,
+                where: t.name,
+            });
+    }
+}

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

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { type CliExitCode } from '../cli-run.js';
+export declare function run(argv: string[]): Promise<CliExitCode>;