@uipath/maestro-builder-sdk 6.64.0 → 6.65.0

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

@@ -16,6 +16,7 @@
  * `case/check.ts`, not here.
  */
 import { type ExprDiagnostic } from '../core/expr-check.js';
+import { CompileRefusal } from '../core/compile-refusal.js';
 import type { BuiltCase } from './case-sdk.js';
 /** A diagnostic plus the part of the case it was found in. */
 export interface CaseLocatedDiagnostic extends ExprDiagnostic {
@@ -29,7 +30,7 @@ export declare function checkCaseExpressions(built: BuiltCase): CaseLocatedDiagn
  * `FlowBuildError`: `message` lists every problem; `diagnostics` carries them
  * structured.
  */
-export declare class CaseBuildError extends Error {
+export declare class CaseBuildError extends CompileRefusal {
     readonly diagnostics: CaseLocatedDiagnostic[];
     constructor(built: BuiltCase, diagnostics: CaseLocatedDiagnostic[]);
 }

package/dist/case/case-expr-check.js

@@ -16,6 +16,7 @@
  * `case/check.ts`, not here.
  */
 import { checkExpression } from '../core/expr-check.js';
+import { CompileRefusal } from '../core/compile-refusal.js';
 import { defaultActionOutputVar } from './action-output-var.js';
 const NOUN = 'case variable';
 const NAMESPACE = 'vars';
@@ -83,12 +84,13 @@ export function checkCaseExpressions(built) {
  * `FlowBuildError`: `message` lists every problem; `diagnostics` carries them
  * structured.
  */
-export class CaseBuildError extends Error {
+export class CaseBuildError extends CompileRefusal {
     diagnostics;
     constructor(built, diagnostics) {
         const label = built.name || built.id || 'case';
         const lines = diagnostics.map((d) => `  ✗ [${d.code}] in ${d.where}: ${d.message}${d.suggestion ? ` (did you mean "${d.suggestion}"?)` : ''}`);
-        super(`Cannot build case "${label}" — ${diagnostics.length} expression problem(s):\n${lines.join('\n')}`);
+        // The first problem's code; `diagnostics` carries every one.
+        super(diagnostics[0]?.code ?? 'EXPR_UNDECLARED_REF', `Cannot build case "${label}" — ${diagnostics.length} expression problem(s):\n${lines.join('\n')}`);
         this.name = 'CaseBuildError';
         this.diagnostics = diagnostics;
     }

package/dist/case/case-sdk.js

@@ -3,6 +3,7 @@ import { isTriggerDescriptor } from '../core/connectors.js';
 import { checkCaseExpressions, CaseBuildError } from './case-expr-check.js';
 import { CASE_FORMAT_PROFILE, CASE_SCHEMA_VERSIONS, recordAuthoredCaseVersion } from './format-profile.js';
 import { schemaVersionRefusal } from '../schema-version.js';
+import { CompileRefusal } from '../core/compile-refusal.js';
 export { preserveCaseJson } from './preserve.js';
 export { CaseBuildError } from './case-expr-check.js';
 /**
@@ -115,11 +116,11 @@ export function eventTrigger(descriptorOrOpts = {}, descriptorOpts = {}) {
     const object = descriptor ? undefined : opts.object;
     if (object !== undefined) {
         if (opts.subscription)
-            throw new Error('eventTrigger: pass the watched object as `subscription.object` on a resolved subscription, not as `object`.');
+            throw new CompileRefusal('CASE_TRIGGER_OBJECT_AND_SUBSCRIPTION', 'eventTrigger: pass the watched object as `subscription.object` on a resolved subscription, not as `object`.');
         // Refuse padding rather than trim it: the value must match the SDD's
         // source object exactly, and a silent trim would hide the typo.
         if (typeof object !== 'string' || !object.trim() || object !== object.trim())
-            throw new Error('eventTrigger: `object` must be a non-empty string with no surrounding whitespace.');
+            throw new CompileRefusal('CASE_TRIGGER_OBJECT_INVALID', 'eventTrigger: `object` must be a non-empty string with no surrounding whitespace.');
     }
     return {
         kind: 'event',
@@ -178,7 +179,7 @@ class TaskBuilder {
     }
     setKind(kind) {
         if (this._kind)
-            throw new Error(`task "${this._name}": kind already set to "${this._kind}", cannot also be "${kind}".`);
+            throw new CompileRefusal('TASK_KIND_TWICE', `task "${this._name}": kind already set to "${this._kind}", cannot also be "${kind}".`);
         this._kind = kind;
     }
     reference(kind, name, opts = {}) {
@@ -530,7 +531,7 @@ class TaskBuilder {
             const type = (v.type ?? 'string');
             if ('assign' in v) {
                 if ('source' in v)
-                    throw new Error(`task "${this._name}": output "${name}" sets both source and assign — use source to extract a result field, assign for a custom output.`);
+                    throw new CompileRefusal('TASK_OUTPUT_SOURCE_AND_ASSIGN', `task "${this._name}": output "${name}" sets both source and assign — use source to extract a result field, assign for a custom output.`);
                 this._outputs.push({ var: name, source: customOutputValue(v.assign), type, custom: true });
             }
             else {
@@ -553,7 +554,7 @@ class TaskBuilder {
     /** @internal */
     _build() {
         if (!this._kind)
-            throw new Error(`task "${this._name}" has no kind — call .process()/.agent()/.rpa()/.action()/.connector()/.waitForTimer()/… once.`);
+            throw new CompileRefusal('TASK_NO_KIND', `task "${this._name}" has no kind — call .process()/.agent()/.rpa()/.action()/.connector()/.waitForTimer()/… once.`);
         // Task input binding is reference-mode only (REF_IO): a connector task takes
         // its inputs in `.connector()` / `.waitForConnector()`. Output extracts also
         // work on connector and wait-for-connector tasks: the task writes its own
@@ -563,14 +564,14 @@ class TaskBuilder {
         const REF_IO = new Set(['process', 'agent', 'rpa', 'api-workflow', 'case-management', 'flow-process', 'function', 'business-rule']);
         const CONNECTOR_OUTPUTS = new Set(['connector', 'wait-for-connector']);
         if (this._inputs && !REF_IO.has(this._kind))
-            throw new Error(`task "${this._name}": .inputs()/.outputs() are only supported on reference-mode tasks (process/agent/rpa/api-workflow/case-management/flow-process/function/business-rule), not "${this._kind}". A connector task takes its inputs in .connector() / .waitForConnector().`);
+            throw new CompileRefusal('TASK_INPUTS_UNSUPPORTED', `task "${this._name}": .inputs()/.outputs() are only supported on reference-mode tasks (process/agent/rpa/api-workflow/case-management/flow-process/function/business-rule), not "${this._kind}". A connector task takes its inputs in .connector() / .waitForConnector().`);
         if (this._outputs && !REF_IO.has(this._kind) && !CONNECTOR_OUTPUTS.has(this._kind))
-            throw new Error(`task "${this._name}": .outputs() is only supported on reference-mode tasks (process/agent/rpa/api-workflow/case-management/flow-process/function/business-rule) and on connector / wait-for-connector tasks, not "${this._kind}".`);
+            throw new CompileRefusal('TASK_OUTPUTS_UNSUPPORTED', `task "${this._name}": .outputs() is only supported on reference-mode tasks (process/agent/rpa/api-workflow/case-management/flow-process/function/business-rule) and on connector / wait-for-connector tasks, not "${this._kind}".`);
         if (REF_IO.has(this._kind) && !this._ref && (this._inputs || this._outputs))
-            throw new Error(`task "${this._name}": an unresolved reference task cannot declare inputs or outputs.`);
+            throw new CompileRefusal('TASK_IO_UNRESOLVED_REFERENCE', `task "${this._name}": an unresolved reference task cannot declare inputs or outputs.`);
         if (this._kind === 'wait-for-connector' && this._outputs
             && !(this._waitConnector && 'connector' in this._waitConnector && 'event' in this._waitConnector))
-            throw new Error(`task "${this._name}": a placeholder wait-for-connector task has no event response to extract outputs from — name the event (.waitForConnector(<trigger descriptor>) or { connector, event }).`);
+            throw new CompileRefusal('TASK_OUTPUTS_PLACEHOLDER_EVENT', `task "${this._name}": a placeholder wait-for-connector task has no event response to extract outputs from — name the event (.waitForConnector(<trigger descriptor>) or { connector, event }).`);
         return {
             name: this._name,
             kind: this._kind,
@@ -824,7 +825,7 @@ class CaseBuilder {
     schemaVersion(version) {
         const refusal = schemaVersionRefusal(CASE_SCHEMA_VERSIONS, version);
         if (refusal)
-            throw new Error(refusal);
+            throw new CompileRefusal('SCHEMA_VERSION_UNSUPPORTED', refusal);
         this._schemaVersion = version;
         return this;
     }

package/dist/case/load.js

@@ -3,6 +3,7 @@ import { pathToFileURL } from 'node:url';
 import { resolve } from 'node:path';
 import { existsSync, statSync } from 'node:fs';
 import { useThisSdkForAuthoredSource } from '../sdk-resolve.js';
+import { CompileRefusal } from '../core/compile-refusal.js';
 /**
  * Resolve a user argument (a `.ts` path or a BaseName) to a case source file.
  *
@@ -19,16 +20,16 @@ export function resolveCaseFile(arg) {
         if (existsSync(resolved) && statSync(resolved).isFile())
             return resolved;
     }
-    throw new Error(`case source not found: tried ${candidates.join(', ')}`);
+    throw new CompileRefusal('CASE_SOURCE_NOT_FOUND', `case source not found: tried ${candidates.join(', ')}`);
 }
 export async function loadBuiltCase(file) {
     useThisSdkForAuthoredSource();
     const mod = await import(pathToFileURL(file).href);
     const exp = mod.default ?? mod.casePlan ?? mod.case;
     if (!exp)
-        throw new Error(`${file} has no default export. Add: export default casePlan('id')...build();`);
+        throw new CompileRefusal('CASE_NO_DEFAULT_EXPORT', `${file} has no default export. Add: export default casePlan('id')...build();`);
     const built = typeof exp.build === 'function' ? exp.build() : exp;
     if (!built || !Array.isArray(built.stages))
-        throw new Error(`${file} default export is not a built case. Did you call .build()?`);
+        throw new CompileRefusal('CASE_EXPORT_NOT_BUILT', `${file} default export is not a built case. Did you call .build()?`);
     return built;
 }

package/dist/case/serialize.js

@@ -19,16 +19,17 @@ import { bindingLabelRefusal } from '../core/binding-messages.js';
 import { resolveEventWhere } from '../core/lookups.js';
 import { resolveCaseSubscription } from './subscription.js';
 import { dedupeConditionNames } from './rule-names.js';
-import { externalDescriptorRefusal, externalHybridRefusal, externalServiceType, isExternalExecutionMode } from './external.js';
+import { EXTERNAL_TASK_DESCRIPTOR_CONTRACT, EXTERNAL_TASK_HYBRID_UNSUPPORTED, externalDescriptorRefusal, externalHybridRefusal, externalServiceType, isExternalExecutionMode, } from './external.js';
 import { CASE_FORMAT_PROFILE, CASE_SCHEMA_VERSIONS } from './format-profile.js';
 import { isResourceLabelRefusal, resolveResourceRef, resourceIdentity } from './resource-identity.js';
 import { ownEntry } from '../core/own-entry.js';
 import { resolveSchemaVersion } from '../schema-version.js';
 import { caseJsonPreservation, caseJsonPreservationErrors, } from './preserve.js';
 import { businessEventProblems } from './business-event-shape.js';
-import { readEventFilter, eventFilterProblem, eventFilterTreeLeaf } from '../core/event-filters.js';
+import { readEventFilterLeaf, eventFilterTreeLeaf } from '../core/event-filters.js';
 import { responseJsonSchema } from '../core/connector-response-schema.js';
 import { ruleShapeProblems } from './rule-options.js';
+import { CompileRefusal } from '../core/compile-refusal.js';
 /**
  * Condition `displayName` allocator.
  *
@@ -135,7 +136,7 @@ export function serialize(built, opts = {}) {
     built.stages.forEach((stage, si) => {
         const sid = ids.stageId(`stage:${stage.label}`);
         if (resolver.stageIdByLabel.has(stage.label))
-            throw new Error(`duplicate stage label "${stage.label}".`);
+            throw new CompileRefusal('DUP_STAGE', `duplicate stage label "${stage.label}".`);
         resolver.stageIdByLabel.set(stage.label, sid);
         stageIds.push(sid);
         taskIds.push([]);
@@ -143,7 +144,7 @@ export function serialize(built, opts = {}) {
             taskIds[si].push([]);
             lane.forEach((task) => {
                 if (seenTaskNames.has(task.name))
-                    throw new Error(`duplicate task displayName "${task.name}" — task names must be unique across the case.`);
+                    throw new CompileRefusal('DUP_TASK', `duplicate task displayName "${task.name}" — task names must be unique across the case.`);
                 seenTaskNames.add(task.name);
                 const tid = ids.taskId(`task:${stage.label}/${task.name}`);
                 taskIds[si][li].push(tid);
@@ -187,13 +188,13 @@ export function serialize(built, opts = {}) {
     const selectNextStage = built.stages.flatMap((stage) => stage.exit)
         .filter((exit) => exit.selectNextStage !== undefined);
     if (selectNextStage.length > 1)
-        throw new Error('select-next-stage can be configured on at most one stage exit per case.');
+        throw new CompileRefusal('SELECT_NEXT_STAGE_MULTIPLE', 'select-next-stage can be configured on at most one stage exit per case.');
     if (selectNextStage[0]?.selectNextStage) {
         const { objectName, connector } = selectNextStage[0].selectNextStage;
         if (selectNextStage[0].type !== 'wait-for-user')
-            throw new Error('select-next-stage requires an exit with type "wait-for-user".');
+            throw new CompileRefusal('SELECT_NEXT_STAGE_EXIT_TYPE', 'select-next-stage requires an exit with type "wait-for-user".');
         if (!objectName.trim())
-            throw new Error('select-next-stage objectName must be non-empty.');
+            throw new CompileRefusal('SELECT_NEXT_STAGE_OBJECT_NAME', 'select-next-stage objectName must be non-empty.');
         const context = [];
         if (connector) {
             context.push(io('connectorKey', 'string', { value: connector.connectorKey }));
@@ -234,7 +235,7 @@ export function serialize(built, opts = {}) {
     if (built.businessEvents?.length) {
         const [problem] = businessEventProblems(built.businessEvents);
         if (problem)
-            throw new Error(problem.message);
+            throw new CompileRefusal(problem.code, problem.message);
         metadata.businessEvents = built.businessEvents.map(emitBusinessEvent);
     }
     // Variables: declared vars + the readable companions that REASSIGNED task
@@ -347,11 +348,11 @@ function applyAuthorLayout(result, authored) {
     const nodes = result.nodes;
     const layoutValue = result.layout;
     if (layoutValue !== undefined && (!layoutValue || typeof layoutValue !== 'object' || Array.isArray(layoutValue)))
-        throw new Error('case layout: preserved layout must be an object before authored entries can be applied.');
+        throw new Error('internal SDK error: case layout: preserved layout must be an object before authored entries can be applied.');
     const existingLayout = (layoutValue ?? {});
     const existingNodes = existingLayout.nodes;
     if (existingNodes !== undefined && (!existingNodes || typeof existingNodes !== 'object' || Array.isArray(existingNodes)))
-        throw new Error('case layout: preserved layout.nodes must be an object before authored entries can be applied.');
+        throw new Error('internal SDK error: case layout: preserved layout.nodes must be an object before authored entries can be applied.');
     const layoutNodes = { ...(existingNodes ?? {}) };
     const layout = { ...existingLayout, nodes: layoutNodes };
     for (const entry of entries) {
@@ -363,16 +364,16 @@ function applyAuthorLayout(result, authored) {
             return trigger && label === entry.name;
         });
         if (matches.length !== 1)
-            throw new Error(`case layout: ${entry.kind} "${entry.name}" matches ${matches.length} emitted nodes; expected exactly 1.`);
+            throw new CompileRefusal('CASE_LAYOUT_NODE_MATCH', `case layout: ${entry.kind} "${entry.name}" matches ${matches.length} emitted nodes; expected exactly 1.`);
         const nodeId = matches[0].id;
         if (typeof nodeId !== 'string' || !nodeId)
-            throw new Error(`case layout: ${entry.kind} "${entry.name}" has no emitted node id.`);
+            throw new Error(`internal SDK error: case layout: ${entry.kind} "${entry.name}" has no emitted node id.`);
         const unknown = Object.keys(entry.layout).filter((field) => !CASE_NODE_LAYOUT_FIELDS.includes(field));
         if (unknown.length)
-            throw new Error(`case layout: ${entry.kind} "${entry.name}" has unsupported field "${unknown[0]}".`);
+            throw new CompileRefusal('CASE_LAYOUT_UNKNOWN_FIELD', `case layout: ${entry.kind} "${entry.name}" has unsupported field "${unknown[0]}".`);
         const previous = layoutNodes[nodeId];
         if (previous !== undefined && (!previous || typeof previous !== 'object' || Array.isArray(previous)))
-            throw new Error(`case layout: preserved entry for ${entry.kind} "${entry.name}" must be an object.`);
+            throw new Error(`internal SDK error: case layout: preserved entry for ${entry.kind} "${entry.name}" must be an object.`);
         const merged = { ...(previous ?? {}) };
         for (const field of CASE_NODE_LAYOUT_FIELDS)
             if (entry.layout[field] !== undefined)
@@ -394,7 +395,7 @@ export function applyPreservation(result, preservation, options = {}) {
         return result;
     const errors = caseJsonPreservationErrors(preservation);
     if (errors.length)
-        throw new Error(`invalid Case JSON preservation payload: ${errors.join('; ')}`);
+        throw new CompileRefusal('PRESERVATION_COLLISION', `invalid Case JSON preservation payload: ${errors.join('; ')}`);
     applyPreservedIdentities(result, preservation);
     Object.assign(result, preservation.topLevel ?? {});
     Object.assign(result.metadata, preservation.metadata ?? {});
@@ -402,7 +403,7 @@ export function applyPreservation(result, preservation, options = {}) {
     if (caseAppConfig && preservation.caseAppConfigFields) {
         for (const [field, value] of Object.entries(preservation.caseAppConfigFields.fields ?? {})) {
             if (!options.overwrite && Object.prototype.hasOwnProperty.call(caseAppConfig, field))
-                throw new Error(`preserved caseAppConfig field "${field}" collides with serializer-owned output.`);
+                throw new CompileRefusal('PRESERVATION_FIELD_COLLISION', `preserved caseAppConfig field "${field}" collides with serializer-owned output.`);
             caseAppConfig[field] = value;
         }
         for (const entry of preservation.caseAppConfigFields.sections ?? []) {
@@ -411,7 +412,7 @@ export function applyPreservation(result, preservation, options = {}) {
                 continue;
             for (const [field, value] of Object.entries(entry.fields)) {
                 if (!options.overwrite && Object.prototype.hasOwnProperty.call(section, field))
-                    throw new Error(`preserved Case App section "${entry.id}" field "${field}" collides with serializer-owned output.`);
+                    throw new CompileRefusal('PRESERVATION_FIELD_COLLISION', `preserved Case App section "${entry.id}" field "${field}" collides with serializer-owned output.`);
                 section[field] = value;
             }
         }
@@ -431,10 +432,10 @@ export function applyPreservation(result, preservation, options = {}) {
             if (!row && options.overwrite)
                 continue;
             if (!row)
-                throw new Error(`preserved variable "${name}" was not regenerated in variables.${lane}.`);
+                throw new CompileRefusal('PRESERVATION_TARGET_MISSING', `preserved variable "${name}" was not regenerated in variables.${lane}.`);
             for (const [field, value] of Object.entries(fields)) {
                 if (!options.overwrite && Object.prototype.hasOwnProperty.call(row, field))
-                    throw new Error(`preserved variable "${name}" field "${field}" collides with serializer-owned output.`);
+                    throw new CompileRefusal('PRESERVATION_FIELD_COLLISION', `preserved variable "${name}" field "${field}" collides with serializer-owned output.`);
                 row[field] = value;
             }
         }
@@ -446,7 +447,7 @@ export function applyPreservation(result, preservation, options = {}) {
             if (!row && options.overwrite)
                 continue;
             if (!row)
-                throw new Error(`legacy variable default "${name}" was not regenerated in variables.${lane}.`);
+                throw new CompileRefusal('PRESERVATION_TARGET_MISSING', `legacy variable default "${name}" was not regenerated in variables.${lane}.`);
             const encoded = JSON.stringify(value);
             // The legacy row exists to carry the NON-STRING spelling of a value the
             // serializer now writes as a string, so it is only applicable while the two
@@ -457,7 +458,7 @@ export function applyPreservation(result, preservation, options = {}) {
             if (row.default !== encoded) {
                 if (options.overwrite)
                     continue;
-                throw new Error(`legacy variable default "${name}" does not match the serializer-owned default.`);
+                throw new CompileRefusal('PRESERVATION_LEGACY_DEFAULT_MISMATCH', `legacy variable default "${name}" does not match the serializer-owned default.`);
             }
             row.default = value;
         }
@@ -485,7 +486,7 @@ export function applyPreservation(result, preservation, options = {}) {
                 if (task[field] === value)
                     continue;
                 if (!options.overwrite)
-                    throw new Error(`preserved task "${entry.stage}/${entry.task}" field "${field}" collides with serializer-owned output.`);
+                    throw new CompileRefusal('PRESERVATION_FIELD_COLLISION', `preserved task "${entry.stage}/${entry.task}" field "${field}" collides with serializer-owned output.`);
             }
             task[field] = value;
         }
@@ -509,7 +510,7 @@ export function applyPreservation(result, preservation, options = {}) {
         if (!trigger && options.overwrite)
             continue;
         if (!trigger)
-            throw new Error(`trigger ${index + 1} was not regenerated for preserved data fields.`);
+            throw new CompileRefusal('PRESERVATION_TARGET_MISSING', `trigger ${index + 1} was not regenerated for preserved data fields.`);
         Object.assign(trigger.data, fields);
     }
     if (preservation.nodes?.length) {
@@ -721,7 +722,7 @@ function emitVariables(vars, ids, triggerNodeByRef) {
             return { default: vd.default };
         const value = JSON.stringify(vd.default);
         if (value === undefined)
-            throw new TypeError(`Case variable "${vd.name}" has a default that cannot be JSON encoded.`);
+            throw new CompileRefusal('CASE_VAR_DEFAULT_NOT_JSON', `Case variable "${vd.name}" has a default that cannot be JSON encoded.`);
         return { default: value };
     };
     const readableCompanion = (vd) => ({
@@ -748,7 +749,7 @@ function emitVariables(vars, ids, triggerNodeByRef) {
             // to the trigger node, so it does not also take a root companion.
             const node = triggerNodeByRef.get(vd.sourceTrigger);
             if (!node)
-                throw new Error(`In-arg "${vd.name}" is bound via { from } to a trigger that was not added with .trigger(...).`);
+                throw new CompileRefusal('CASE_IN_ARG_TRIGGER_NOT_ADDED', `In-arg "${vd.name}" is bound via { from } to a trigger that was not added with .trigger(...).`);
             entry.default = vd.default === undefined ? '' : encodedDefault(vd).default;
             entry.elementId = node.id;
             inputs.push(entry);
@@ -1038,7 +1039,7 @@ function withOutputExtracts(data, task, ids, resolver) {
     const own = Array.isArray(data.outputs) ? data.outputs : [];
     const elementId = own.find((row) => typeof row.elementId === 'string')?.elementId;
     if (!elementId)
-        throw new Error(`task "${task.name}": output extracts need the task's resolved response output.`);
+        throw new CompileRefusal('TASK_OUTPUTS_NO_RESPONSE', `task "${task.name}": output extracts need the task's resolved response output.`);
     data.outputs = [
         ...own,
         ...task.outputs.map((o, i) => emitTaskOutput(o, elementId, ids, `${elementId}:out:${i}:${o.var}`, resolver)),
@@ -1076,7 +1077,7 @@ function isResolvedSubscription(spec) {
  * by the archived v1 artifacts. Placeholder bags never enter this path. */
 function resolvedSubscriptionBag(kind, spec, resolver, elementId, where) {
     if (!resolver.library)
-        throw new Error(`${kind === 'trigger' ? 'event trigger' : 'wait-for-connector'} needs the connector library — `
+        throw new CompileRefusal('LIBRARY_REQUIRED', `${kind === 'trigger' ? 'event trigger' : 'wait-for-connector'} needs the connector library — `
             + `pass { library } to serialize or use uip maestro case compile --library.`);
     const rc = resolveCaseSubscription(resolver.library, kind, spec, { where, bindings: resolver.bindings });
     const op = rc.entry.operation ?? {};
@@ -1121,12 +1122,13 @@ function subscriptionMetadata(rc, op, filters, elementId) {
         filters: filters.map((entry, index) => {
             // Same authored shape as a flow's event filter, same designer grammar (see
             // `event-filters.ts`); a malformed leaf is refused rather than dropped.
-            const { read } = readEventFilter(entry);
-            if (!read)
-                throw new Error(`event filter ${index} must carry a field and exactly one operator — got ${JSON.stringify(entry)}.`);
-            const problem = eventFilterProblem(read);
-            if (problem)
-                throw new Error(`event filter ${index} on \`${read.field}\`: ${problem}`);
+            // The code `check` gives the same leaf (`core/event-checks.ts`).
+            const judged = readEventFilterLeaf(entry);
+            if (judged.code !== undefined)
+                throw new CompileRefusal(judged.code, judged.problem !== undefined
+                    ? `event filter ${index} on \`${judged.read?.field}\`: ${judged.problem}`
+                    : `event filter ${index} must carry a field and exactly one operator — got ${JSON.stringify(entry)}.`);
+            const { read } = judged;
             return {
                 ...eventFilterTreeLeaf(read),
                 uiId: stableUuid(`${elementId}:${read.field}:${String(read.value)}:${index}`),
@@ -1393,14 +1395,14 @@ function referenceBindings(kind, authored, resolver, ids, taskName) {
     // literal value, so the task binds exactly as the literal form does.
     const ref = resolveResourceRef(authored, resolver.bindings, `Task "${taskName}"`);
     if (isResourceLabelRefusal(ref))
-        throw new Error(`[${ref.code}] ${ref.message}`);
+        throw new CompileRefusal(ref.code, ref.message);
     const binding = kind === 'business-rule'
         ? { resource: BUSINESS_RULE_RESOURCE }
         : kind === 'action'
             ? { resource: ACTION_APP_RESOURCE }
             : ownEntry(REFERENCE_BINDING, kind);
     if (!binding)
-        throw new Error(`task kind "${kind}" is not a published-resource task.`);
+        throw new Error(`internal SDK error: task kind "${kind}" is not a published-resource task.`);
     // An in-solution resource (`folder: 'solution_folder'`) keeps the sentinel
     // in its key and binds an empty folderPath — see resource-identity.ts.
     const { resourceKey, folderPath } = resourceIdentity(ref.name, ref.folderPath);
@@ -1459,7 +1461,7 @@ function businessRuleTaskData(task, resolver, elementId, ids) {
  */
 function connectorTaskData(spec, resolver, elementId, where, executionType) {
     if (!resolver.library)
-        throw new Error(`connector task needs the connector library — pass { library } to serialize or use uip maestro case compile --library.`);
+        throw new CompileRefusal('LIBRARY_REQUIRED', `connector task needs the connector library — pass { library } to serialize or use uip maestro case compile --library.`);
     const rc = resolver.library.resolve(spec.key, spec.action, spec.version, spec.object);
     const op = rc.entry.operation ?? {};
     const context = [
@@ -1527,17 +1529,17 @@ function connectorTaskData(spec, resolver, elementId, where, executionType) {
  */
 function externalTaskData(kind, spec, resolver, elementId, where) {
     if (!resolver.library)
-        throw new Error(`${kind} task needs the connector library — pass { library } to serialize or use uip maestro case compile --library.`);
+        throw new CompileRefusal('LIBRARY_REQUIRED', `${kind} task needs the connector library — pass { library } to serialize or use uip maestro case compile --library.`);
     const rc = resolver.library.resolve(spec.connector.key, spec.connector.action, spec.connector.version, spec.connector.object);
     const refused = externalDescriptorRefusal(kind, rc);
     if (refused)
-        throw new Error(refused);
+        throw new CompileRefusal(EXTERNAL_TASK_DESCRIPTOR_CONTRACT, refused);
     if (!isExternalExecutionMode(spec.mode))
-        throw new Error(`${kind} task mode must be the connector object's executionType: "sync", "async" or "hybrid".`);
+        throw new CompileRefusal('EXTERNAL_TASK_MODE', `${kind} task mode must be the connector object's executionType: "sync", "async" or "hybrid".`);
     if (spec.mode === 'hybrid')
-        throw new Error(externalHybridRefusal(where));
+        throw new CompileRefusal(EXTERNAL_TASK_HYBRID_UNSUPPORTED, externalHybridRefusal(where));
     if (!spec.connector.connection || !spec.connector.folder)
-        throw new Error(`${kind} task requires non-empty connection and folder binding names.`);
+        throw new CompileRefusal(spec.connector.connection ? 'EXTERNAL_TASK_FOLDER' : 'EXTERNAL_TASK_CONNECTION', `${kind} task requires non-empty connection and folder binding names.`);
     const data = connectorTaskData(spec.connector, resolver, elementId, where, spec.mode);
     const context = data.context;
     const metadataAt = context.findIndex((row) => row.name === 'metadata');
@@ -1642,7 +1644,7 @@ function folderBindingRef(resolver, name, connection, site) {
     for (const row of resolver.bindingSink.values()) {
         if (row.resourceKey === connection.resourceKey && row.propertyAttribute === 'folderKey'
             && row.default !== folderKey)
-            throw new Error(`${site.where}: connection "${connection.resourceKey}" is bound to two folders: `
+            throw new CompileRefusal('BINDING_CONNECTION_TWO_FOLDERS', `${site.where}: connection "${connection.resourceKey}" is bound to two folders: `
                 + `"${String(row.name)}" (${String(row.default)}) and "${name}" (${folderKey}). `
                 + `A connection lives in one folder; use the same folder binding for every task on it.`);
     }
@@ -1826,13 +1828,13 @@ function emitRules(rules, seed, ownerId, ids, resolver, site) {
 function emitRule(r, seed, ownerId, ids, resolver, site) {
     const [shape] = ruleShapeProblems(r);
     if (shape)
-        throw new Error(`${shape.message.replace(/^Rule /, 'rule ')} (in ${site})`);
+        throw new CompileRefusal(shape.code, `${shape.message.replace(/^Rule /, 'rule ')} (in ${site})`);
     const ruleId = ids.ruleId(seed);
     const out = { rule: r.rule, id: ruleId };
     if (r.rule === 'selected-stage-completed' || r.rule === 'selected-stage-exited') {
         const sid = r.stage && resolver.stageIdByLabel.get(r.stage);
         if (!sid)
-            throw new Error(`rule "${r.rule}" references unknown stage "${r.stage}".`);
+            throw new CompileRefusal('UNKNOWN_STAGE_REF', `rule "${r.rule}" references unknown stage "${r.stage}".`);
         out[CASE_FORMAT_PROFILE.selectedStageField] = CASE_FORMAT_PROFILE.selectedStageCardinality === 'singular' ? sid : [sid];
     }
     if (r.rule === 'selected-tasks-completed') {
@@ -1840,7 +1842,7 @@ function emitRule(r, seed, ownerId, ids, resolver, site) {
         out.selectedTasksIds = names.map((n) => {
             const tid = resolver.taskIdByKey.get(n);
             if (!tid)
-                throw new Error(`rule "selected-tasks-completed" references unknown task "${n}".`);
+                throw new CompileRefusal('UNKNOWN_TASK_REF', `rule "selected-tasks-completed" references unknown task "${n}".`);
             return tid;
         });
     }
@@ -1853,12 +1855,12 @@ function emitRule(r, seed, ownerId, ids, resolver, site) {
         // preallocated id. `slaId` alone = a breach rule; adding `escalationId` = at-risk.
         const slaId = r.sla && resolver.slaIdByName.get(r.sla);
         if (!slaId)
-            throw new Error(`rule "sla-status-change" references unknown SLA "${r.sla}" — declare it with .sla({ displayName: "${r.sla}", … }).`);
+            throw new CompileRefusal('UNKNOWN_SLA_REF', `rule "sla-status-change" references unknown SLA "${r.sla}" — declare it with .sla({ displayName: "${r.sla}", … }).`);
         out.slaId = slaId;
         if (r.escalation) {
             const escId = resolver.escalationIdByName.get(r.escalation);
             if (!escId)
-                throw new Error(`rule "sla-status-change" references unknown escalation "${r.escalation}".`);
+                throw new CompileRefusal('UNKNOWN_ESCALATION_REF', `rule "sla-status-change" references unknown escalation "${r.escalation}".`);
             out.escalationId = escId;
         }
     }
@@ -1866,9 +1868,9 @@ function emitRule(r, seed, ownerId, ids, resolver, site) {
         // The event is matched by its exact name at run time; a rule without one
         // listens for nothing, so both a missing and an undeclared name refuse.
         if (!r.businessEvent)
-            throw new Error(`rule "api-event" in ${site} names no business event — write rule('api-event', { businessEvent: '<name>' }) with a name declared by .businessEvent('<name>').`);
+            throw new CompileRefusal('API_EVENT_NO_BUSINESS_EVENT', `rule "api-event" in ${site} names no business event — write rule('api-event', { businessEvent: '<name>' }) with a name declared by .businessEvent('<name>').`);
         if (!resolver.businessEvents.has(r.businessEvent))
-            throw new Error(`rule "api-event" in ${site} listens for business event "${r.businessEvent}", which the case does not declare — add .businessEvent(${JSON.stringify(r.businessEvent)}).`);
+            throw new CompileRefusal('UNKNOWN_BUSINESS_EVENT', `rule "api-event" in ${site} listens for business event "${r.businessEvent}", which the case does not declare — add .businessEvent(${JSON.stringify(r.businessEvent)}).`);
         out.businessEventType = r.businessEvent;
     }
     if (r.expression)
@@ -1939,7 +1941,7 @@ function emitExit(c, seed, ownerId, label, ids, resolver) {
     if (c.exitToStage) {
         const sid = resolver.stageIdByLabel.get(c.exitToStage);
         if (!sid)
-            throw new Error(`exit condition routes to unknown stage "${c.exitToStage}".`);
+            throw new CompileRefusal('UNKNOWN_EXIT_STAGE', `exit condition routes to unknown stage "${c.exitToStage}".`);
         out.exitToStageId = sid;
     }
     return out;

package/dist/core/event-filters.d.ts

@@ -98,6 +98,26 @@ export declare function readEventFilter(leaf: unknown): {
     keys: EventFilterOperatorKey[];
     read?: ReadEventFilter;
 };
+/** A code `check` gives a filter leaf it refuses (`core/event-checks.ts`). */
+export type EventFilterLeafCode = 'EVENT_FILTER_NO_FIELD' | 'EVENT_FILTER_MANY_OPERATORS' | 'EVENT_FILTER_NO_VALUE' | 'EVENT_FILTER_BACKSLASH' | 'EVENT_FILTER_BAD_VALUE';
+/**
+ * Read an authored filter leaf and judge it the way `check` does: the first
+ * code `core/event-checks.ts` gives the leaf, in the same order, or the read
+ * condition when the leaf lowers. A serializer that refuses a bad leaf with one
+ * message calls this, so its code cannot drift from check's.
+ *
+ * @example
+ * readEventFilterLeaf({ field: 'subject', contains: 'Report' }) // { read: { field: 'subject', operator: 'contains', value: 'Report' } }
+ * readEventFilterLeaf({ contains: 'Report' })                   // { code: 'EVENT_FILTER_NO_FIELD', read: { field: '', ... } }
+ */
+export declare function readEventFilterLeaf(leaf: unknown): {
+    code?: undefined;
+    read: ReadEventFilter;
+} | {
+    code: EventFilterLeafCode;
+    read?: ReadEventFilter;
+    problem?: string;
+};
 export declare function isIsoDateString(value: unknown): value is string;
 /**
  * Why a filter cannot be lowered, or `undefined` when it can. Two shapes are

package/dist/core/event-filters.js

@@ -81,6 +81,33 @@ export function readEventFilter(leaf) {
         return { keys };
     return { keys, read: { field: String(f.field ?? ''), operator: keys[0], value } };
 }
+/**
+ * Read an authored filter leaf and judge it the way `check` does: the first
+ * code `core/event-checks.ts` gives the leaf, in the same order, or the read
+ * condition when the leaf lowers. A serializer that refuses a bad leaf with one
+ * message calls this, so its code cannot drift from check's.
+ *
+ * @example
+ * readEventFilterLeaf({ field: 'subject', contains: 'Report' }) // { read: { field: 'subject', operator: 'contains', value: 'Report' } }
+ * readEventFilterLeaf({ contains: 'Report' })                   // { code: 'EVENT_FILTER_NO_FIELD', read: { field: '', ... } }
+ */
+export function readEventFilterLeaf(leaf) {
+    const { keys, read } = readEventFilter(leaf);
+    const field = leaf?.field;
+    if (typeof field !== 'string' || field === '')
+        return { code: 'EVENT_FILTER_NO_FIELD', read };
+    if (keys.length > 1)
+        return { code: 'EVENT_FILTER_MANY_OPERATORS' };
+    if (!read)
+        return { code: 'EVENT_FILTER_NO_VALUE' };
+    const problem = eventFilterProblem(read);
+    const ambiguous = typeof read.value === 'string' ? jmesStringProblem(read.value) : undefined;
+    if (ambiguous)
+        return { code: 'EVENT_FILTER_BACKSLASH', read, problem: problem ?? ambiguous };
+    if (problem)
+        return { code: 'EVENT_FILTER_BAD_VALUE', read, problem };
+    return { read };
+}
 /** An ISO-8601 calendar date, optionally with a time part — what the designer serializes a date filter as. */
 const ISO_DATE = /^\d{4}-\d{2}-\d{2}(?:[T ]\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:?\d{2})?)?$/;
 export function isIsoDateString(value) {

package/dist/core/refusals.d.ts

@@ -1,7 +1,14 @@
 /** What a code means for `check` and `compile`. */
 export type RefusalClass = 'lint' | 'lowering' | 'draft';
-/** Every code the Flow compile path emits → its class. Sorted by code. */
+/**
+ * Every code the Flow and Case compile paths emit → its class. Sorted by code.
+ *
+ * One table, because codes are one namespace: `check` codes such as
+ * `CONNECTOR_INPUT` and `LIBRARY_REQUIRED` are shared across families, and a
+ * code means the same condition in each.
+ */
 export declare const REFUSALS: {
+    readonly ACTION_FIELD_UNKNOWN_KEY: "lint";
     readonly AGENTIC_EMPTY_RETURNS: "lint";
     readonly AGENTIC_KEY_NOT_KEY: "lint";
     readonly AGENTIC_LOCAL_FORM_UNVERIFIED: "lint";
@@ -43,17 +50,36 @@ export declare const REFUSALS: {
     readonly APIWF_READ_NOT_OUTPUT: "lint";
     readonly APIWF_READ_UNKNOWN_FIELD: "lint";
     readonly APIWF_READ_WITHOUT_RETURNS: "lint";
+    readonly API_EVENT_NO_BUSINESS_EVENT: "lowering";
     readonly ARM_SCOPED_OUTPUT_READ: "lint";
+    readonly BINDING_CONNECTION_TWO_FOLDERS: "lowering";
     readonly BINDING_MISSING: "draft";
     readonly BINDING_PLACEHOLDER_UNRESOLVED: "draft";
     readonly BINDING_SELF_NAME: "draft";
     readonly BINDING_UNDECLARED: "draft";
     readonly BRANCH_CONST_COND: "lint";
     readonly BREAK_OUTSIDE_LOOP: "lowering";
+    readonly BUSINESS_EVENT_NAME: "lowering";
+    readonly BUSINESS_EVENT_PAYLOAD_TYPE: "lowering";
+    readonly BUSINESS_EVENT_UNKNOWN_OPTION: "lowering";
+    readonly BUSINESS_RULE_EMPTY_DATA: "lint";
+    readonly BUSINESS_RULE_OUTPUT_NAME: "lint";
+    readonly BUSINESS_RULE_OUTPUT_SOURCE: "lint";
     readonly CALL_NO_NUMBER: "lint";
     readonly CALL_NUMBER_NOT_E164: "lint";
     readonly CARRIED_DEFINITION_CONFLICT: "lowering";
     readonly CARRIED_DEFINITION_INVALID: "lowering";
+    readonly CASE_APP_DETAILS_LIMIT: "lint";
+    readonly CASE_APP_DETAILS_TYPE: "lint";
+    readonly CASE_EXPORT_NOT_BUILT: "lowering";
+    readonly CASE_IN_ARG_TRIGGER_NOT_ADDED: "lowering";
+    readonly CASE_LAYOUT_NODE_MATCH: "lowering";
+    readonly CASE_LAYOUT_UNKNOWN_FIELD: "lowering";
+    readonly CASE_NO_DEFAULT_EXPORT: "lowering";
+    readonly CASE_SOURCE_NOT_FOUND: "lowering";
+    readonly CASE_TRIGGER_OBJECT_AND_SUBSCRIPTION: "lowering";
+    readonly CASE_TRIGGER_OBJECT_INVALID: "lowering";
+    readonly CASE_VAR_DEFAULT_NOT_JSON: "lowering";
     readonly CEQL_UNPARSEABLE: "lowering";
     readonly CHECK_INCOMPLETE: "lowering";
     readonly COMPILE_FAILED: "lowering";
@@ -68,6 +94,7 @@ export declare const REFUSALS: {
     readonly CONNECTOR_NO_FLOW_DEFINITION: "lowering";
     readonly CONNECTOR_OBJECT_NOT_GENERIC: "lowering";
     readonly CONNECTOR_OBJECT_REQUIRED: "draft";
+    readonly CONNECTOR_OUTPUT_SOURCE: "lint";
     readonly CONNECTOR_RESOLVE_FAILED: "lowering";
     readonly CONTINUE_OUTSIDE_LOOP: "lowering";
     readonly CONTRIBUTION_BINDING_UNRESOLVED: "draft";
@@ -112,11 +139,17 @@ export declare const REFUSALS: {
     readonly DOC_NO_FILEREF: "lint";
     readonly DOWHILE_CONST_COND: "lint";
     readonly DOWHILE_LIMIT: "lint";
+    readonly DUP_BUSINESS_EVENT: "lowering";
     readonly DUP_CASE: "lint";
     readonly DUP_END_NAME: "lowering";
+    readonly DUP_EXIT_RULE: "lint";
+    readonly DUP_RULE_NAME: "lint";
+    readonly DUP_STAGE: "lowering";
     readonly DUP_STEP: "lowering";
+    readonly DUP_TASK: "lowering";
     readonly EMPTY_ARM: "lint";
     readonly EMPTY_LOOP: "lint";
+    readonly EMPTY_REQUIRED_FIELD: "lint";
     readonly ENTRY_POINT_DUP_ID: "lowering";
     readonly ENTRY_POINT_INPUT_COLLISION: "lint";
     readonly ENTRY_POINT_NO_SHARED_BODY: "lowering";
@@ -124,6 +157,8 @@ export declare const REFUSALS: {
     readonly ERROR_FIELD_UNDECLARED: "lint";
     readonly ERROR_READ_OUTSIDE_HANDLER: "lowering";
     readonly ERROR_READ_VIA_OUT: "lint";
+    readonly ESCALATION_NO_RECIPIENTS: "lint";
+    readonly ESCALATION_ZERO_ATRISK_PCT: "lint";
     readonly EVENT_BYOA_UNVERIFIED: "lowering";
     readonly EVENT_FILTERS_NOT_ARRAY: "lint";
     readonly EVENT_FILTER_BACKSLASH: "lowering";
@@ -141,14 +176,23 @@ export declare const REFUSALS: {
     readonly EVENT_SCOPE_NOT_TAKEN: "lint";
     readonly EVENT_UNKNOWN: "lowering";
     readonly EVENT_UNPREPARED: "lint";
+    readonly EXCEPTION_STAGE_REQUIRED: "lint";
     readonly EXPR_SYNTAX: "lowering";
     readonly EXPR_UNDECLARED_REF: "lowering";
+    readonly EXTERNAL_TASK_CONNECTION: "lowering";
+    readonly EXTERNAL_TASK_DESCRIPTOR: "lint";
+    readonly EXTERNAL_TASK_DESCRIPTOR_CONTRACT: "lowering";
+    readonly EXTERNAL_TASK_EMPTY_DATA: "lint";
+    readonly EXTERNAL_TASK_FOLDER: "lowering";
+    readonly EXTERNAL_TASK_HYBRID_UNSUPPORTED: "lowering";
+    readonly EXTERNAL_TASK_MODE: "lowering";
     readonly EXTRACT_SCHEMA_SHAPE: "lint";
     readonly FILE_NOT_FOUND: "lowering";
     readonly FIRE_AND_FORGET_READ: "lint";
     readonly FIRE_AND_FORGET_RETURNS: "lowering";
     readonly FLOW_EXPORT_NOT_BUILT: "lowering";
     readonly FLOW_NO_DEFAULT_EXPORT: "lowering";
+    readonly FLOW_PROCESS_EMPTY_DATA: "lint";
     readonly FLOW_SOURCE_NOT_FOUND: "lowering";
     readonly FORM_TRIGGER_NO_INPUTS: "lint";
     readonly FUNCTION_EMPTY_RETURNS: "lint";
@@ -319,13 +363,19 @@ export declare const REFUSALS: {
     readonly LOOP_PARALLEL_LEGACY: "lint";
     readonly LOOP_VERSION_UNSUPPORTED: "lowering";
     readonly MOCK_HAS_NO_OUTPUT: "lint";
+    readonly NAME_HYGIENE: "lint";
     readonly NODE_FAMILY_REGISTRATION: "lowering";
     readonly NODE_VERSION_UNREGISTERED: "lowering";
+    readonly NO_CASE_COMPLETION: "lint";
     readonly NO_ID: "lint";
+    readonly NO_REQUIRED_TASK: "lint";
     readonly NO_RETURN: "lint";
+    readonly NO_STAGES: "lint";
     readonly OBJECT_UNPREPARED: "lint";
     readonly ONERROR_NO_ERROR_PORT: "lowering";
     readonly OUTPUT_BACKING_COLLISION: "lowering";
+    readonly OUTPUT_FORWARD_READ: "lint";
+    readonly OUTPUT_SELF_REFERENCE: "lint";
     readonly OUTPUT_TYPE_MISMATCH: "lint";
     readonly OUTPUT_VAR_MISMATCH: "lowering";
     readonly PACKAGE_NODES_NOT_PLATFORM: "lint";
@@ -338,6 +388,10 @@ export declare const REFUSALS: {
     readonly PORT_ALREADY_ROUTED: "lowering";
     readonly PORT_EMPTY_PATH: "lowering";
     readonly PORT_NO_SOURCE_STEP: "lowering";
+    readonly PRESERVATION_COLLISION: "lowering";
+    readonly PRESERVATION_FIELD_COLLISION: "lowering";
+    readonly PRESERVATION_LEGACY_DEFAULT_MISMATCH: "lowering";
+    readonly PRESERVATION_TARGET_MISSING: "lowering";
     readonly QUEUE_BAD_DATE: "lint";
     readonly QUEUE_BAD_PRIORITY: "lint";
     readonly QUEUE_ITEM_EXPR_UNSUPPORTED: "lowering";
@@ -366,6 +420,8 @@ export declare const REFUSALS: {
     readonly REF_TO_OWN_LOOP: "lint";
     readonly REF_UNKNOWN_TARGET: "lowering";
     readonly REF_UNREACHABLE_AFTER: "lint";
+    readonly RESOURCE_BINDING_UNDECLARED: "lowering";
+    readonly RESOURCE_REF_IS_BINDING: "lowering";
     readonly RETURN_UPDATES_SAME_VAR: "lowering";
     readonly RPA_KEY_NOT_KEY: "lint";
     readonly RPA_LOCAL_HAS_FOLDER: "lint";
@@ -378,6 +434,9 @@ export declare const REFUSALS: {
     readonly RPA_READ_NOT_OUTPUT: "lint";
     readonly RPA_READ_UNKNOWN_FIELD: "lint";
     readonly RPA_READ_WITHOUT_RETURNS: "lint";
+    readonly RULE_PLACEMENT: "lint";
+    readonly RULE_TASKS_REQUIRED: "lint";
+    readonly RULE_UNKNOWN_OPTION: "lowering";
     readonly SCHEDULE_CRON_VERSION: "lowering";
     readonly SCHEDULE_NEVER_FIRES: "lint";
     readonly SCHEDULE_NOT_ISO: "lint";
@@ -391,6 +450,9 @@ export declare const REFUSALS: {
     readonly SCRIPT_FUNCTION_UNLOWERABLE: "lowering";
     readonly SCRIPT_RETURNS_UNKNOWN_TYPE: "lint";
     readonly SDK_RESOLVE_HOOK_MISSING: "lowering";
+    readonly SELECT_NEXT_STAGE_EXIT_TYPE: "lowering";
+    readonly SELECT_NEXT_STAGE_MULTIPLE: "lowering";
+    readonly SELECT_NEXT_STAGE_OBJECT_NAME: "lowering";
     readonly SEND_MESSAGE_NO_CONTENT: "lint";
     readonly SEND_MESSAGE_NO_EXCHANGE: "lint";
     readonly SHARED_INPUT_IN_SUBFLOW: "lowering";
@@ -401,6 +463,10 @@ export declare const REFUSALS: {
     readonly SHARED_INPUT_TARGET_IS_INPUT: "lowering";
     readonly SHARED_INPUT_TYPE_MISMATCH: "lowering";
     readonly SINGLE_CONVERSATION_TRIGGER: "lint";
+    readonly SLA_COUNT_RANGE: "lint";
+    readonly SLA_NONPOSITIVE: "lint";
+    readonly SLA_NO_ESCALATIONS: "lint";
+    readonly STAGE_NO_COMPLETION: "lint";
     readonly STEP_ID_COLLISION: "lowering";
     readonly STEP_NOT_ACTION: "lowering";
     readonly STEP_READ_WITHOUT_OUTPUT: "lint";
@@ -432,10 +498,22 @@ export declare const REFUSALS: {
     readonly SWITCH_HAS_NO_OUTPUT: "lint";
     readonly SWITCH_NO_CASES: "lint";
     readonly SWITCH_ON_UNUSED: "lint";
+    readonly TASK_INPUTS_UNSUPPORTED: "lowering";
+    readonly TASK_IO_TYPE: "lint";
+    readonly TASK_IO_UNRESOLVED_REFERENCE: "lowering";
+    readonly TASK_KIND_TWICE: "lowering";
+    readonly TASK_NO_ENTRY: "lint";
+    readonly TASK_NO_KIND: "lowering";
+    readonly TASK_OUTPUTS_NO_RESPONSE: "lowering";
+    readonly TASK_OUTPUTS_PLACEHOLDER_EVENT: "lowering";
+    readonly TASK_OUTPUTS_UNSUPPORTED: "lowering";
+    readonly TASK_OUTPUT_SOURCE_AND_ASSIGN: "lowering";
+    readonly TASK_REENTRY_IGNORED: "lint";
     readonly TEMPLATED_EXITS_ONLY: "lowering";
     readonly TERMINATE_HAS_NO_OUTPUT: "lint";
     readonly TERMINATE_NOT_ARM_HEAD: "lint";
     readonly TERMINATE_UNREACHABLE_AFTER: "lint";
+    readonly TIMER_VALUE_REQUIRED: "lint";
     readonly TRANSFORM_AGG_NO_ALIAS: "lint";
     readonly TRANSFORM_AGG_NO_FIELD: "lint";
     readonly TRANSFORM_BAD_VOCAB: "lint";
@@ -459,13 +537,22 @@ export declare const REFUSALS: {
     readonly TRIGGER_INPUTS_IGNORED: "lint";
     readonly TRIGGER_UNKNOWN_KIND: "lowering";
     readonly TYPESCRIPT_UNAVAILABLE: "lowering";
+    readonly UNKNOWN_BUSINESS_EVENT: "lowering";
+    readonly UNKNOWN_ESCALATION_REF: "lowering";
+    readonly UNKNOWN_EXIT_STAGE: "lowering";
     readonly UNKNOWN_LOOP_FIELD: "lint";
     readonly UNKNOWN_REF: "lint";
+    readonly UNKNOWN_RULE: "lowering";
+    readonly UNKNOWN_SLA_REF: "lowering";
+    readonly UNKNOWN_STAGE_REF: "lowering";
+    readonly UNKNOWN_TASK_REF: "lowering";
     readonly UPDATES_NOT_SUPPORTED: "lowering";
     readonly UPDATE_INPUT_READONLY: "lint";
     readonly UPDATE_UNKNOWN_VAR: "lint";
     readonly VARIABLE_NAME_COLLISION: "lowering";
     readonly VARS_BRACKET_READ: "lint";
+    readonly VERSION_DEPRECATED: "lint";
+    readonly VERSION_MISMATCH: "lint";
     readonly VOICE_AGENT_ITERATIONS: "lint";
     readonly VOICE_AGENT_NO_PROMPT: "lint";
     readonly VOICE_CALL_CONTEXT_NOT_OBJECT: "lint";

package/dist/core/refusals.js

@@ -1,13 +1,13 @@
 /**
- * Every diagnostic and refusal code the Flow compile path emits, with its class
+ * Every diagnostic and refusal code the Flow and Case compile paths emit, with its class
  * (docs/CHECK_COMPILE_CONTRACT_DESIGN.md §3.1, #1440):
  *
- *   - `lint`: the flow is probably wrong. Only `check` reports it; it never
+ *   - `lint`: the flow (or case) is probably wrong. Only `check` reports it; it never
  *     stops `compile` from writing. A serializer warning (`CONNECTION_STUB`) is
  *     `lint` too: it never blocks.
- *   - `lowering`: `compile` cannot write a correct `.flow`. It always stops
- *     `compile`; `check` reports it too, from the serializer it runs in collect
- *     mode (`SerializeOpts.collect`), so the rule lives in one place.
+ *   - `lowering`: `compile` cannot write a correct `.flow` (or caseplan). It always stops
+ *     `compile`; for a Flow, `check` reports it too, from the serializer it runs in
+ *     collect mode (`SerializeOpts.collect`), so the rule lives in one place.
  *   - `draft`: an unfinished canvas node (no connection yet, a required input
  *     left empty, a generic operation with no object). These are the codes a
  *     draft-tolerant compile collects instead of throwing (`DraftCode` in
@@ -32,14 +32,21 @@
  * duplicate name.
  *
  * FB017 (`tests/lint/rules/fb017-coded-refusals.ts`) keeps this table and the
- * source in step: every code-shaped string literal in the Flow compile path is
+ * source in step: every code-shaped string literal in those compile paths is
  * a key here, and every key is emitted somewhere. The `<PREFIX>_READ_*` codes
  * of the `codePrefix` node types are composed at run time (`check.ts`
  * `checkDeclaredOutputRead`), so they appear here but not as literals.
  */
 import { ownEntry } from './own-entry.js';
-/** Every code the Flow compile path emits → its class. Sorted by code. */
+/**
+ * Every code the Flow and Case compile paths emit → its class. Sorted by code.
+ *
+ * One table, because codes are one namespace: `check` codes such as
+ * `CONNECTOR_INPUT` and `LIBRARY_REQUIRED` are shared across families, and a
+ * code means the same condition in each.
+ */
 export const REFUSALS = {
+    ACTION_FIELD_UNKNOWN_KEY: 'lint',
     AGENTIC_EMPTY_RETURNS: 'lint',
     AGENTIC_KEY_NOT_KEY: 'lint',
     AGENTIC_LOCAL_FORM_UNVERIFIED: 'lint',
@@ -81,17 +88,36 @@ export const REFUSALS = {
     APIWF_READ_NOT_OUTPUT: 'lint',
     APIWF_READ_UNKNOWN_FIELD: 'lint',
     APIWF_READ_WITHOUT_RETURNS: 'lint',
+    API_EVENT_NO_BUSINESS_EVENT: 'lowering',
     ARM_SCOPED_OUTPUT_READ: 'lint',
+    BINDING_CONNECTION_TWO_FOLDERS: 'lowering',
     BINDING_MISSING: 'draft',
     BINDING_PLACEHOLDER_UNRESOLVED: 'draft',
     BINDING_SELF_NAME: 'draft',
     BINDING_UNDECLARED: 'draft',
     BRANCH_CONST_COND: 'lint',
     BREAK_OUTSIDE_LOOP: 'lowering',
+    BUSINESS_EVENT_NAME: 'lowering',
+    BUSINESS_EVENT_PAYLOAD_TYPE: 'lowering',
+    BUSINESS_EVENT_UNKNOWN_OPTION: 'lowering',
+    BUSINESS_RULE_EMPTY_DATA: 'lint',
+    BUSINESS_RULE_OUTPUT_NAME: 'lint',
+    BUSINESS_RULE_OUTPUT_SOURCE: 'lint',
     CALL_NO_NUMBER: 'lint',
     CALL_NUMBER_NOT_E164: 'lint',
     CARRIED_DEFINITION_CONFLICT: 'lowering',
     CARRIED_DEFINITION_INVALID: 'lowering',
+    CASE_APP_DETAILS_LIMIT: 'lint',
+    CASE_APP_DETAILS_TYPE: 'lint',
+    CASE_EXPORT_NOT_BUILT: 'lowering',
+    CASE_IN_ARG_TRIGGER_NOT_ADDED: 'lowering',
+    CASE_LAYOUT_NODE_MATCH: 'lowering',
+    CASE_LAYOUT_UNKNOWN_FIELD: 'lowering',
+    CASE_NO_DEFAULT_EXPORT: 'lowering',
+    CASE_SOURCE_NOT_FOUND: 'lowering',
+    CASE_TRIGGER_OBJECT_AND_SUBSCRIPTION: 'lowering',
+    CASE_TRIGGER_OBJECT_INVALID: 'lowering',
+    CASE_VAR_DEFAULT_NOT_JSON: 'lowering',
     CEQL_UNPARSEABLE: 'lowering',
     // Only `check --baseline` reports it: collection stopped at a scope-level
     // refusal, and `compile` (and `merge --baseline-from`) stops at that refusal.
@@ -109,6 +135,7 @@ export const REFUSALS = {
     CONNECTOR_NO_FLOW_DEFINITION: 'lowering',
     CONNECTOR_OBJECT_NOT_GENERIC: 'lowering',
     CONNECTOR_OBJECT_REQUIRED: 'draft',
+    CONNECTOR_OUTPUT_SOURCE: 'lint',
     CONNECTOR_RESOLVE_FAILED: 'lowering',
     CONTINUE_OUTSIDE_LOOP: 'lowering',
     CONTRIBUTION_BINDING_UNRESOLVED: 'draft',
@@ -153,11 +180,17 @@ export const REFUSALS = {
     DOC_NO_FILEREF: 'lint',
     DOWHILE_CONST_COND: 'lint',
     DOWHILE_LIMIT: 'lint',
+    DUP_BUSINESS_EVENT: 'lowering',
     DUP_CASE: 'lint',
     DUP_END_NAME: 'lowering',
+    DUP_EXIT_RULE: 'lint',
+    DUP_RULE_NAME: 'lint',
+    DUP_STAGE: 'lowering',
     DUP_STEP: 'lowering',
+    DUP_TASK: 'lowering',
     EMPTY_ARM: 'lint',
     EMPTY_LOOP: 'lint',
+    EMPTY_REQUIRED_FIELD: 'lint',
     ENTRY_POINT_DUP_ID: 'lowering',
     ENTRY_POINT_INPUT_COLLISION: 'lint',
     ENTRY_POINT_NO_SHARED_BODY: 'lowering',
@@ -165,6 +198,8 @@ export const REFUSALS = {
     ERROR_FIELD_UNDECLARED: 'lint',
     ERROR_READ_OUTSIDE_HANDLER: 'lowering',
     ERROR_READ_VIA_OUT: 'lint',
+    ESCALATION_NO_RECIPIENTS: 'lint',
+    ESCALATION_ZERO_ATRISK_PCT: 'lint',
     EVENT_BYOA_UNVERIFIED: 'lowering',
     EVENT_FILTERS_NOT_ARRAY: 'lint',
     EVENT_FILTER_BACKSLASH: 'lowering',
@@ -182,14 +217,23 @@ export const REFUSALS = {
     EVENT_SCOPE_NOT_TAKEN: 'lint',
     EVENT_UNKNOWN: 'lowering',
     EVENT_UNPREPARED: 'lint',
+    EXCEPTION_STAGE_REQUIRED: 'lint',
     EXPR_SYNTAX: 'lowering',
     EXPR_UNDECLARED_REF: 'lowering',
+    EXTERNAL_TASK_CONNECTION: 'lowering',
+    EXTERNAL_TASK_DESCRIPTOR: 'lint',
+    EXTERNAL_TASK_DESCRIPTOR_CONTRACT: 'lowering',
+    EXTERNAL_TASK_EMPTY_DATA: 'lint',
+    EXTERNAL_TASK_FOLDER: 'lowering',
+    EXTERNAL_TASK_HYBRID_UNSUPPORTED: 'lowering',
+    EXTERNAL_TASK_MODE: 'lowering',
     EXTRACT_SCHEMA_SHAPE: 'lint',
     FILE_NOT_FOUND: 'lowering',
     FIRE_AND_FORGET_READ: 'lint',
     FIRE_AND_FORGET_RETURNS: 'lowering',
     FLOW_EXPORT_NOT_BUILT: 'lowering',
     FLOW_NO_DEFAULT_EXPORT: 'lowering',
+    FLOW_PROCESS_EMPTY_DATA: 'lint',
     FLOW_SOURCE_NOT_FOUND: 'lowering',
     FORM_TRIGGER_NO_INPUTS: 'lint',
     FUNCTION_EMPTY_RETURNS: 'lint',
@@ -360,13 +404,19 @@ export const REFUSALS = {
     LOOP_PARALLEL_LEGACY: 'lint',
     LOOP_VERSION_UNSUPPORTED: 'lowering',
     MOCK_HAS_NO_OUTPUT: 'lint',
+    NAME_HYGIENE: 'lint',
     NODE_FAMILY_REGISTRATION: 'lowering',
     NODE_VERSION_UNREGISTERED: 'lowering',
+    NO_CASE_COMPLETION: 'lint',
     NO_ID: 'lint',
+    NO_REQUIRED_TASK: 'lint',
     NO_RETURN: 'lint',
+    NO_STAGES: 'lint',
     OBJECT_UNPREPARED: 'lint',
     ONERROR_NO_ERROR_PORT: 'lowering',
     OUTPUT_BACKING_COLLISION: 'lowering',
+    OUTPUT_FORWARD_READ: 'lint',
+    OUTPUT_SELF_REFERENCE: 'lint',
     OUTPUT_TYPE_MISMATCH: 'lint',
     OUTPUT_VAR_MISMATCH: 'lowering',
     PACKAGE_NODES_NOT_PLATFORM: 'lint',
@@ -379,6 +429,10 @@ export const REFUSALS = {
     PORT_ALREADY_ROUTED: 'lowering',
     PORT_EMPTY_PATH: 'lowering',
     PORT_NO_SOURCE_STEP: 'lowering',
+    PRESERVATION_COLLISION: 'lowering',
+    PRESERVATION_FIELD_COLLISION: 'lowering',
+    PRESERVATION_LEGACY_DEFAULT_MISMATCH: 'lowering',
+    PRESERVATION_TARGET_MISSING: 'lowering',
     QUEUE_BAD_DATE: 'lint',
     QUEUE_BAD_PRIORITY: 'lint',
     QUEUE_ITEM_EXPR_UNSUPPORTED: 'lowering',
@@ -407,6 +461,8 @@ export const REFUSALS = {
     REF_TO_OWN_LOOP: 'lint',
     REF_UNKNOWN_TARGET: 'lowering',
     REF_UNREACHABLE_AFTER: 'lint',
+    RESOURCE_BINDING_UNDECLARED: 'lowering',
+    RESOURCE_REF_IS_BINDING: 'lowering',
     RETURN_UPDATES_SAME_VAR: 'lowering',
     RPA_KEY_NOT_KEY: 'lint',
     RPA_LOCAL_HAS_FOLDER: 'lint',
@@ -419,6 +475,9 @@ export const REFUSALS = {
     RPA_READ_NOT_OUTPUT: 'lint',
     RPA_READ_UNKNOWN_FIELD: 'lint',
     RPA_READ_WITHOUT_RETURNS: 'lint',
+    RULE_PLACEMENT: 'lint',
+    RULE_TASKS_REQUIRED: 'lint',
+    RULE_UNKNOWN_OPTION: 'lowering',
     SCHEDULE_CRON_VERSION: 'lowering',
     SCHEDULE_NEVER_FIRES: 'lint',
     SCHEDULE_NOT_ISO: 'lint',
@@ -432,6 +491,9 @@ export const REFUSALS = {
     SCRIPT_FUNCTION_UNLOWERABLE: 'lowering',
     SCRIPT_RETURNS_UNKNOWN_TYPE: 'lint',
     SDK_RESOLVE_HOOK_MISSING: 'lowering',
+    SELECT_NEXT_STAGE_EXIT_TYPE: 'lowering',
+    SELECT_NEXT_STAGE_MULTIPLE: 'lowering',
+    SELECT_NEXT_STAGE_OBJECT_NAME: 'lowering',
     SEND_MESSAGE_NO_CONTENT: 'lint',
     SEND_MESSAGE_NO_EXCHANGE: 'lint',
     SHARED_INPUT_IN_SUBFLOW: 'lowering',
@@ -442,6 +504,10 @@ export const REFUSALS = {
     SHARED_INPUT_TARGET_IS_INPUT: 'lowering',
     SHARED_INPUT_TYPE_MISMATCH: 'lowering',
     SINGLE_CONVERSATION_TRIGGER: 'lint',
+    SLA_COUNT_RANGE: 'lint',
+    SLA_NONPOSITIVE: 'lint',
+    SLA_NO_ESCALATIONS: 'lint',
+    STAGE_NO_COMPLETION: 'lint',
     STEP_ID_COLLISION: 'lowering',
     STEP_NOT_ACTION: 'lowering',
     STEP_READ_WITHOUT_OUTPUT: 'lint',
@@ -473,10 +539,22 @@ export const REFUSALS = {
     SWITCH_HAS_NO_OUTPUT: 'lint',
     SWITCH_NO_CASES: 'lint',
     SWITCH_ON_UNUSED: 'lint',
+    TASK_INPUTS_UNSUPPORTED: 'lowering',
+    TASK_IO_TYPE: 'lint',
+    TASK_IO_UNRESOLVED_REFERENCE: 'lowering',
+    TASK_KIND_TWICE: 'lowering',
+    TASK_NO_ENTRY: 'lint',
+    TASK_NO_KIND: 'lowering',
+    TASK_OUTPUTS_NO_RESPONSE: 'lowering',
+    TASK_OUTPUTS_PLACEHOLDER_EVENT: 'lowering',
+    TASK_OUTPUTS_UNSUPPORTED: 'lowering',
+    TASK_OUTPUT_SOURCE_AND_ASSIGN: 'lowering',
+    TASK_REENTRY_IGNORED: 'lint',
     TEMPLATED_EXITS_ONLY: 'lowering',
     TERMINATE_HAS_NO_OUTPUT: 'lint',
     TERMINATE_NOT_ARM_HEAD: 'lint',
     TERMINATE_UNREACHABLE_AFTER: 'lint',
+    TIMER_VALUE_REQUIRED: 'lint',
     TRANSFORM_AGG_NO_ALIAS: 'lint',
     TRANSFORM_AGG_NO_FIELD: 'lint',
     TRANSFORM_BAD_VOCAB: 'lint',
@@ -500,13 +578,22 @@ export const REFUSALS = {
     TRIGGER_INPUTS_IGNORED: 'lint',
     TRIGGER_UNKNOWN_KIND: 'lowering',
     TYPESCRIPT_UNAVAILABLE: 'lowering',
+    UNKNOWN_BUSINESS_EVENT: 'lowering',
+    UNKNOWN_ESCALATION_REF: 'lowering',
+    UNKNOWN_EXIT_STAGE: 'lowering',
     UNKNOWN_LOOP_FIELD: 'lint',
     UNKNOWN_REF: 'lint',
+    UNKNOWN_RULE: 'lowering',
+    UNKNOWN_SLA_REF: 'lowering',
+    UNKNOWN_STAGE_REF: 'lowering',
+    UNKNOWN_TASK_REF: 'lowering',
     UPDATES_NOT_SUPPORTED: 'lowering',
     UPDATE_INPUT_READONLY: 'lint',
     UPDATE_UNKNOWN_VAR: 'lint',
     VARIABLE_NAME_COLLISION: 'lowering',
     VARS_BRACKET_READ: 'lint',
+    VERSION_DEPRECATED: 'lint',
+    VERSION_MISMATCH: 'lint',
     VOICE_AGENT_ITERATIONS: 'lint',
     VOICE_AGENT_NO_PROMPT: 'lint',
     VOICE_CALL_CONTEXT_NOT_OBJECT: 'lint',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.64.0",
+  "version": "6.65.0",
   "description": "Build UiPath Flow, Case, and BPMN artifacts by writing TypeScript.",
   "license": "MIT",
   "homepage": "https://docs.uipath.com/maestro",
@@ -100,5 +100,5 @@
     "@types/node": "^22.7.0",
     "esbuild": "^0.28.1"
   },
-  "gitref": "f484cbfa0ea499ec18eb2f15c5200b3f0c059f95"
+  "gitref": "cef5c166db15d92f544e04c9817e280551ecc9dd"
 }