@uipath/maestro-builder-sdk 6.46.6 → 6.47.0

package/dist/case/business-event-shape.d.ts

@@ -0,0 +1,27 @@
+/**
+ * The problems with a case's declared business events that `check` reports and
+ * `serialize` refuses: an empty name, a name declared twice (an `api-event`
+ * rule matches by name, so it could not tell the two apart), an option
+ * `.businessEvent()` does not read (it would be dropped from the caseplan), or a
+ * payload of a type the Designer does not write.
+ *
+ * A payload is an object or array schema (`type` absent, `'object'` or
+ * `'array'`): the two shapes the Case Designer and `uip maestro case sdd
+ * convert` write. Any other type, such as `{ type: 'string' }`, is refused.
+ * Nobody has confirmed that Studio Web's Business events panel loads one; once
+ * someone does, this can be loosened.
+ */
+import type { BuiltBusinessEvent } from './case-sdk.js';
+/** One problem with a declared business event. */
+export interface BusinessEventProblem {
+    code: 'BUSINESS_EVENT_NAME' | 'DUP_BUSINESS_EVENT' | 'BUSINESS_EVENT_UNKNOWN_OPTION' | 'BUSINESS_EVENT_PAYLOAD_TYPE';
+    message: string;
+}
+/**
+ * Report every problem with the case's business events, in declaration order.
+ * Options set to `undefined` count as absent.
+ *
+ * @param events - The events as `.businessEvent()` recorded them.
+ * @returns The problems, empty when every event is well formed.
+ */
+export declare function businessEventProblems(events: readonly BuiltBusinessEvent[]): BusinessEventProblem[];

package/dist/case/business-event-shape.js

@@ -0,0 +1,45 @@
+/** The keys a declared business event carries; any other is refused. */
+const BUSINESS_EVENT_KEYS = ['name', 'description', 'payload'];
+/**
+ * Report every problem with the case's business events, in declaration order.
+ * Options set to `undefined` count as absent.
+ *
+ * @param events - The events as `.businessEvent()` recorded them.
+ * @returns The problems, empty when every event is well formed.
+ */
+export function businessEventProblems(events) {
+    const problems = [];
+    const seen = new Set();
+    for (const event of events) {
+        if (typeof event.name !== 'string' || !event.name.trim())
+            problems.push({ code: 'BUSINESS_EVENT_NAME', message: 'A business event has an empty name — rules match events by name.' });
+        else if (seen.has(event.name))
+            problems.push({
+                code: 'DUP_BUSINESS_EVENT',
+                message: `Business event "${event.name}" is declared twice — rules match events by name, so each name must be unique.`,
+            });
+        else
+            seen.add(event.name);
+        for (const key of Object.keys(event))
+            if (!BUSINESS_EVENT_KEYS.includes(key) && event[key] !== undefined)
+                problems.push({
+                    code: 'BUSINESS_EVENT_UNKNOWN_OPTION',
+                    message: `Business event "${String(event.name)}" does not take option "${key}", so it would be dropped from the caseplan — ` +
+                        `.businessEvent() takes "description" and "payload" (the payload's JSON Schema object; the caseplan's "schema" string is written from it).`,
+                });
+        const payload = event.payload;
+        if (payload !== undefined) {
+            const isRecord = typeof payload === 'object' && payload !== null && !Array.isArray(payload);
+            const type = isRecord ? payload.type : undefined;
+            if (!isRecord || (type !== undefined && type !== 'object' && type !== 'array'))
+                problems.push({
+                    code: 'BUSINESS_EVENT_PAYLOAD_TYPE',
+                    message: `Business event "${String(event.name)}" payload must be an object or array schema (no "type", type "object" or type "array"), ` +
+                        `e.g. { type: 'object', properties: { amount: { type: 'number' } } }` +
+                        (isRecord ? `; got type ${JSON.stringify(type)}.` : '; got a value that is not a JSON Schema object.') +
+                        ` Other types are refused until Studio Web's Business events panel is confirmed to load them.`,
+                });
+        }
+    }
+    return problems;
+}

package/dist/case/case-sdk.d.ts

@@ -24,7 +24,7 @@ export { preserveCaseJson } from './preserve.js';
 export type { CaseJsonPreservation, PreservedCaseNode, PreservedTaskFields, PreservedVariableLane } from './preserve.js';
 export { CaseBuildError } from './case-expr-check.js';
 export type { CaseLocatedDiagnostic } from './case-expr-check.js';
-export type CaseRuleType = 'case-entered' | 'required-tasks-completed' | 'required-stages-completed' | 'selected-stage-completed' | 'selected-stage-exited' | 'selected-tasks-completed' | 'current-stage-entered' | 'adhoc' | 'runs-sequentially' | 'user-selected-stage' | 'wait-for-connector' | 'sla-status-change';
+export type CaseRuleType = 'case-entered' | 'required-tasks-completed' | 'required-stages-completed' | 'selected-stage-completed' | 'selected-stage-exited' | 'selected-tasks-completed' | 'current-stage-entered' | 'adhoc' | 'runs-sequentially' | 'user-selected-stage' | 'wait-for-connector' | 'sla-status-change' | 'api-event';
 export interface RuleOpts {
     /**
      * Symbolic stage label (for `selected-stage-completed` / `selected-stage-exited`).
@@ -72,6 +72,14 @@ export interface RuleOpts {
      * a **breach** rule (`slaId` alone). Resolved to `escalationId`.
      */
     escalation?: string;
+    /**
+     * For an `api-event` rule — the **name of the business event** it listens for,
+     * e.g. `rule('api-event', { businessEvent: 'Invoice Approved' })`. Declare the
+     * event on the case with {@link CaseBuilder.businessEvent}. Emitted as the
+     * rule's `businessEventType`; the match is on the exact name, so an
+     * undeclared or misspelled name never fires.
+     */
+    businessEvent?: string;
     /** A `=js:` gate on case state (for `adhoc`, or as an extra guard on any rule). */
     expression?: string;
 }
@@ -680,6 +688,29 @@ export interface CaseLayout {
     /** Trigger node layout keyed by its display name (`Trigger 1` for the default). */
     triggers?: Record<string, CaseNodeLayout>;
 }
+/** Options for {@link CaseBuilder.businessEvent}. */
+export interface BusinessEventOpts {
+    /** What the event means, shown in the Case Designer's Business events panel. */
+    description?: string;
+    /**
+     * The JSON Schema of the payload the sender attaches, e.g.
+     * `{ type: 'object', properties: { amount: { type: 'number' } } }`. Written to
+     * `schema` as a string, with `$schema` defaulted to draft 7, the way the Case
+     * Designer saves it. It must be an object or array schema (no `type`,
+     * `type: 'object'` or `type: 'array'`, the shapes the Designer writes): any
+     * other type is refused (BUSINESS_EVENT_PAYLOAD_TYPE) until someone confirms
+     * Studio Web's Business events panel loads it. Only the empty object schema (`{}`,
+     * `{ type: 'object' }` or `{ type: 'object', properties: {} }`) is left out;
+     * any other object payload, e.g. `{ type: 'object', required: ['a'] }`, is
+     * written.
+     */
+    payload?: Record<string, unknown>;
+}
+/** A declared business event, as the serializer reads it. */
+export interface BuiltBusinessEvent extends BusinessEventOpts {
+    /** The event name an `api-event` rule matches on, exactly. */
+    name: string;
+}
 export interface BuiltCase {
     id: string;
     name: string;
@@ -701,6 +732,8 @@ export interface BuiltCase {
     stages: BuiltStage[];
     caseExit: BuiltCaseExitCondition[];
     slaRules: BuiltSla[];
+    /** Business events an `api-event` rule can listen for (`metadata.businessEvents`). */
+    businessEvents?: BuiltBusinessEvent[];
     /** Empty = the default single manual trigger. */
     triggers: BuiltTrigger[];
     /** Optional designer layout, resolved to final node ids by the serializer. */
@@ -1146,6 +1179,7 @@ declare class CaseBuilder {
     private readonly _stages;
     private readonly _caseExit;
     private readonly _sla;
+    private readonly _businessEvents;
     private readonly _triggers;
     constructor(_id: string);
     /**
@@ -1367,6 +1401,17 @@ declare class CaseBuilder {
      * @returns This builder, so calls chain.
      */
     sla(opts: SlaOpts): this;
+    /**
+     * Declare a business event: a named message an outside system sends to a
+     * running case. An `api-event` rule listens for it by name, e.g.
+     * `.exitWhen(rule('api-event', { businessEvent: 'Invoice Approved' }), …)`.
+     * Emitted to `metadata.businessEvents`.
+     *
+     * @param name - The event name rules match on, exactly.
+     * @param opts - Its description and payload schema.
+     * @returns This builder, so calls chain.
+     */
+    businessEvent(name: string, opts?: BusinessEventOpts): this;
     /**
      * Finish the plan and return the description the serializer writes.
      *

package/dist/case/case-sdk.js

@@ -652,6 +652,7 @@ class CaseBuilder {
     _stages = [];
     _caseExit = [];
     _sla = [];
+    _businessEvents = [];
     _triggers = [];
     constructor(_id) {
         this._id = _id;
@@ -936,6 +937,20 @@ class CaseBuilder {
         this._sla.push(buildSla(opts));
         return this;
     }
+    /**
+     * Declare a business event: a named message an outside system sends to a
+     * running case. An `api-event` rule listens for it by name, e.g.
+     * `.exitWhen(rule('api-event', { businessEvent: 'Invoice Approved' }), …)`.
+     * Emitted to `metadata.businessEvents`.
+     *
+     * @param name - The event name rules match on, exactly.
+     * @param opts - Its description and payload schema.
+     * @returns This builder, so calls chain.
+     */
+    businessEvent(name, opts = {}) {
+        this._businessEvents.push({ name, ...opts });
+        return this;
+    }
     /**
      * Finish the plan and return the description the serializer writes.
      *
@@ -958,6 +973,7 @@ class CaseBuilder {
             stages: this._stages,
             caseExit: this._caseExit,
             slaRules: this._sla,
+            ...(this._businessEvents.length ? { businessEvents: this._businessEvents } : {}),
             triggers: this._triggers,
             ...(this._layout ? { layout: this._layout } : {}),
         };

package/dist/case/check.js

@@ -1,3 +1,5 @@
+import { businessEventProblems } from './business-event-shape.js';
+import { ruleShapeProblems } from './rule-options.js';
 import { types } from '../core/expr.js';
 import { authoredCaseVersion, CASE_FORMAT_PROFILE, CASE_SCHEMA_VERSIONS } from './format-profile.js';
 import { schemaVersionRefusal } from '../schema-version.js';
@@ -212,7 +214,35 @@ export function check(built, opts = {}) {
             code: 'NO_CASE_COMPLETION',
             message: 'Case has no completion rule — add .completeWhen(rule(\'required-stages-completed\')).',
         });
+    // Business events: `metadata.businessEvents` names, matched exactly by an
+    // `api-event` rule's `businessEventType`. `uip maestro case validate` rejects a
+    // rule naming none (BUSINESS_EVENT_NOT_SELECTED) or an undeclared one
+    // (BUSINESS_EVENT_NOT_FOUND); both are reported here, at the rule.
+    const businessEvents = new Set((built.businessEvents ?? []).map((event) => event.name));
+    for (const problem of businessEventProblems(built.businessEvents ?? []))
+        diags.push({ level: 'error', code: problem.code, message: problem.message });
+    const refEvent = (r, where) => {
+        if (r.rule !== 'api-event')
+            return;
+        if (!r.businessEvent)
+            diags.push({
+                level: 'error',
+                code: 'API_EVENT_NO_BUSINESS_EVENT',
+                message: 'Rule "api-event" names no business event, so it listens for nothing — pass { businessEvent: \'<name>\' } with a name declared by .businessEvent(\'<name>\').',
+                where,
+            });
+        else if (!businessEvents.has(r.businessEvent))
+            diags.push({
+                level: 'error',
+                code: 'UNKNOWN_BUSINESS_EVENT',
+                message: `Rule "api-event" listens for business event "${r.businessEvent}", which the case does not declare — add .businessEvent(${JSON.stringify(r.businessEvent)}) to the case.`,
+                where,
+            });
+    };
     const refPlacement = (r, slot, where) => {
+        for (const problem of ruleShapeProblems(r))
+            diags.push({ level: 'error', code: problem.code, message: problem.message, where });
+        refEvent(r, where);
         const bad = ILLEGAL.find((x) => x.rule === r.rule && x.slot === slot);
         if (bad)
             diags.push({
@@ -432,7 +462,7 @@ function checkStage(stage, diags, refStage, refPlacement, bindings) {
     // 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 sig = (c) => JSON.stringify(c.rules.map((g) => g.map((r) => [r.rule, r.stage ?? '', (r.tasks ?? []).join(','), r.expression ?? '', r.businessEvent ?? ''])));
     const seenExit = new Map();
     stage.exit.forEach((c, i) => {
         const k = sig(c);

package/dist/case/decompile.d.ts

@@ -40,6 +40,7 @@ interface Rule {
     uipath?: SubscriptionBag;
     slaId?: string;
     escalationId?: string;
+    businessEventType?: string;
 }
 interface Condition {
     id?: string;
@@ -137,6 +138,12 @@ interface CasePlan {
         caseAppEnabled?: boolean;
         caseExitRules?: Condition[];
         slaRules?: SlaWire[];
+        businessEvents?: Array<{
+            name?: unknown;
+            description?: unknown;
+            schema?: unknown;
+            [key: string]: unknown;
+        }>;
         caseAppConfig?: {
             caseSummary?: unknown;
             sections?: Array<{

package/dist/case/decompile.js

@@ -5,6 +5,7 @@ import { preserveSchemaVersion } from '../schema-version.js';
 import { ownEntry } from '../core/own-entry.js';
 import { isUnrestorableSlotId } from './preserve.js';
 import { isInSolutionKey, SOLUTION_FOLDER } from './resource-identity.js';
+import { offlineBindingLabel } from './ids.js';
 const TASK_KIND_METHOD = {
     process: 'process',
     agent: 'agent',
@@ -260,11 +261,46 @@ function emitRule(rule, refs) {
             entries.push(['escalation', tsLiteral(escalation)]);
         }
     }
+    if (rule.rule === 'api-event' && rule.businessEventType !== undefined)
+        entries.push(['businessEvent', tsLiteral(rule.businessEventType)]);
     if (rule.conditionExpression !== undefined)
         entries.push(['expression', tsLiteral(rule.conditionExpression)]);
     const options = opts(entries);
     return options ? `rule(${tsLiteral(rule.rule)}, ${options})` : `rule(${tsLiteral(rule.rule)})`;
 }
+/**
+ * `.businessEvent(name, { description, payload })` for one
+ * `metadata.businessEvents[]` entry. The Designer stores the payload schema as
+ * a JSON string; it comes back as the object the builder takes, `$schema`
+ * included, so the recompile writes the same string.
+ */
+function businessEventSource(event) {
+    if (!event || typeof event !== 'object' || typeof event.name !== 'string')
+        throw new Error('a business event has no name, which is not authorable.');
+    const unknown = Object.keys(event).filter((key) => !['name', 'description', 'schema'].includes(key));
+    if (unknown.length)
+        throw new Error(`business event "${event.name}" has unsupported field "${unknown[0]}", which is not authorable.`);
+    if (event.description !== undefined && typeof event.description !== 'string')
+        throw new Error(`business event "${event.name}" has a non-string description.`);
+    let payload;
+    if (event.schema !== undefined) {
+        if (typeof event.schema !== 'string')
+            throw new Error(`business event "${event.name}" has a non-string schema.`);
+        try {
+            payload = JSON.parse(event.schema);
+        }
+        catch {
+            throw new Error(`business event "${event.name}" has a schema that is not JSON.`);
+        }
+        if (!payload || typeof payload !== 'object' || Array.isArray(payload))
+            throw new Error(`business event "${event.name}" has a schema that is not a JSON Schema object.`);
+    }
+    const options = opts([
+        ['description', event.description !== undefined ? tsLiteral(event.description) : undefined],
+        ['payload', payload !== undefined ? tsLiteral(payload) : undefined],
+    ]);
+    return options ? `.businessEvent(${tsLiteral(event.name)}, ${options})` : `.businessEvent(${tsLiteral(event.name)})`;
+}
 function emitRuleArg(condition, refs) {
     const groups = condition.rules ?? [];
     const rendered = groups.map((group) => group.map((rule) => emitRule(rule, refs)));
@@ -342,7 +378,18 @@ function bindingName(value, refs) {
     if (typeof value !== 'string' || !value.startsWith('=bindings.'))
         return undefined;
     const id = value.slice('=bindings.'.length);
-    return refs.bindingById.get(id)?.id ?? id;
+    return bindingLabel(refs, id);
+}
+/**
+ * The name a binding reference decompiles to: the authored label when
+ * `serialize` minted the row offline (so a recompile with no bindings.json
+ * mints the same row, and a later bindings.json entry for that label matches),
+ * else the row id (a bindings.json or Designer row, which the recompile
+ * resolves by id).
+ */
+function bindingLabel(refs, id) {
+    const row = refs.bindingById.get(id);
+    return offlineBindingLabel(row) ?? row?.id ?? id;
 }
 /**
  * The literal a resource task's `data.name` / `data.folderPath` names: the
@@ -567,7 +614,7 @@ function externalCall(task, refs, library) {
         const id = value.slice('=bindings.'.length);
         if (!refs.bindingById.has(id))
             throw new Error(`${owner} context ${name} references missing root binding "${id}".`);
-        return id;
+        return bindingLabel(refs, id);
     };
     const identity = library.identifyAction({
         connectorKey: stringValue('connectorKey'),
@@ -1114,7 +1161,7 @@ export function collectPreservation(plan) {
         preservation.topLevel = topLevel;
     const metadataKnown = new Set([
         'caseIdentifier', 'caseIdentifierType', 'caseAppEnabled', 'caseAppConfig', 'publishVersion', 'caseExitRules', 'slaRules',
-        'allowAdhocOptionalStageTasks', 'waitForHumanSelectNextStageDFConnector',
+        'allowAdhocOptionalStageTasks', 'waitForHumanSelectNextStageDFConnector', 'businessEvents',
     ]);
     const metadata = Object.fromEntries(Object.entries(plan.metadata ?? {}).filter(([name]) => !metadataKnown.has(name)));
     if (Object.keys(metadata).length)
@@ -1324,6 +1371,8 @@ export function decompileWithDiagnostics(plan, options = {}) {
     emitVariables(out, depth, plan, triggerNameById);
     triggers.forEach((_trigger, index) => out.line(depth, `.trigger(trigger${index + 1})`));
     (metadata.slaRules ?? []).forEach((sla, index) => out.line(depth, `.sla(${slaSource(sla, index)})`));
+    for (const event of metadata.businessEvents ?? [])
+        out.line(depth, businessEventSource(event));
     for (const node of plan.nodes ?? [])
         if (isStage(node))
             emitStage(out, depth, node, refs, options.library, selectNextStage);

package/dist/case/ids.d.ts

@@ -22,3 +22,29 @@ export declare class IdGen {
     conditionId(seed: string): string;
     ruleId(seed: string): string;
 }
+/**
+ * The seed `serialize` mints an offline binding id from (a connection or
+ * folder label no bindings.json declares). One definition for both sides, so
+ * {@link offlineBindingLabel} can recognise exactly the ids `serialize` mints.
+ *
+ * @param resource - The binding's `resource` (`Connection`).
+ * @param propertyAttribute - `ConnectionId` or `folderKey`.
+ * @param name - The authored label.
+ * @param connectionKey - For a folder bound to a connection, that connection's resourceKey.
+ * @returns The seed string.
+ */
+export declare function offlineBindingSeed(resource: string, propertyAttribute: string, name: string, connectionKey?: string): string;
+/**
+ * The authored label behind a root binding row that `serialize` minted offline,
+ * or `undefined` for any other row (a bindings.json entry, a Designer row).
+ *
+ * Offline the label is the row's only real content: a connection row carries
+ * it as `resourceKey`, a folder row on a connection as `default`, a plain
+ * folder row as `resourceKey`. The row is recognised only when its `id` is
+ * exactly the id that label mints, so decompile can name it by the label and
+ * a recompile with no bindings mints the same row again.
+ *
+ * @param row - A root binding entry.
+ * @returns The label, or `undefined`.
+ */
+export declare function offlineBindingLabel(row: Record<string, unknown> | undefined): string | undefined;

package/dist/case/ids.js

@@ -74,3 +74,52 @@ export class IdGen {
         return this.make('Rule_', 6, seed);
     }
 }
+/**
+ * The seed `serialize` mints an offline binding id from (a connection or
+ * folder label no bindings.json declares). One definition for both sides, so
+ * {@link offlineBindingLabel} can recognise exactly the ids `serialize` mints.
+ *
+ * @param resource - The binding's `resource` (`Connection`).
+ * @param propertyAttribute - `ConnectionId` or `folderKey`.
+ * @param name - The authored label.
+ * @param connectionKey - For a folder bound to a connection, that connection's resourceKey.
+ * @returns The seed string.
+ */
+export function offlineBindingSeed(resource, propertyAttribute, name, connectionKey) {
+    return connectionKey === undefined
+        ? `binding:${resource}:${propertyAttribute}:${name}`
+        : `binding:${resource}:${propertyAttribute}:${connectionKey}:${name}`;
+}
+/** The binding id {@link IdGen.make} gives `seed` at salt 0..3 (`b` + 8 base-62). */
+function offlineBindingIds(seed) {
+    return [0, 1, 2, 3].map((salt) => 'b' + base62(salt === 0 ? seed : `${seed}~${salt}`, 8));
+}
+/**
+ * The authored label behind a root binding row that `serialize` minted offline,
+ * or `undefined` for any other row (a bindings.json entry, a Designer row).
+ *
+ * Offline the label is the row's only real content: a connection row carries
+ * it as `resourceKey`, a folder row on a connection as `default`, a plain
+ * folder row as `resourceKey`. The row is recognised only when its `id` is
+ * exactly the id that label mints, so decompile can name it by the label and
+ * a recompile with no bindings mints the same row again.
+ *
+ * @param row - A root binding entry.
+ * @returns The label, or `undefined`.
+ */
+export function offlineBindingLabel(row) {
+    if (!row || typeof row.id !== 'string')
+        return undefined;
+    const { id, resource, propertyAttribute, resourceKey } = row;
+    if (typeof resource !== 'string' || typeof propertyAttribute !== 'string' || typeof resourceKey !== 'string')
+        return undefined;
+    const candidates = [
+        [resourceKey, offlineBindingSeed(resource, propertyAttribute, resourceKey)],
+    ];
+    if (propertyAttribute === 'folderKey' && typeof row.default === 'string')
+        candidates.push([row.default, offlineBindingSeed(resource, propertyAttribute, row.default, resourceKey)]);
+    for (const [label, seed] of candidates)
+        if (offlineBindingIds(seed).includes(id))
+            return label;
+    return undefined;
+}

package/dist/case/preserve.js

@@ -21,7 +21,7 @@ const TOP_LEVEL_KEYS = new Set([
 const METADATA_KEYS = new Set([
     'caseIdentifier', 'caseIdentifierType', 'caseAppEnabled', 'publishVersion', 'caseExitRules', 'slaRules',
     'caseAppConfig', 'adhocCaseEndData',
-    'allowAdhocOptionalStageTasks', 'waitForHumanSelectNextStageDFConnector',
+    'allowAdhocOptionalStageTasks', 'waitForHumanSelectNextStageDFConnector', 'businessEvents',
 ]);
 const VARIABLE_KEYS = new Set([
     'id', 'name', 'type', 'default', 'body', '_jsonSchema', 'elementId', 'var',

package/dist/case/rule-options.d.ts

@@ -0,0 +1,15 @@
+/** Options each rule kind reads; check and serialize refuse any other key. */
+import type { CaseRule } from './case-sdk.js';
+/** One problem with a rule's shape: an unknown kind, or an option its kind does not read. */
+export interface RuleShapeProblem {
+    code: 'UNKNOWN_RULE' | 'RULE_UNKNOWN_OPTION';
+    message: string;
+}
+/**
+ * Report an unknown rule kind, or each option the rule's kind does not read.
+ * Options set to `undefined` count as absent.
+ *
+ * @param r - The rule as built (`rule(type, opts)` or a literal).
+ * @returns The problems, empty when the rule is well formed.
+ */
+export declare function ruleShapeProblems(r: CaseRule): RuleShapeProblem[];

package/dist/case/rule-options.js

@@ -0,0 +1,46 @@
+import { ownEntry } from '../core/own-entry.js';
+/** `expression` is a gate any rule can carry. */
+const COMMON = ['expression'];
+const RULE_OPTIONS = {
+    'case-entered': [],
+    'required-tasks-completed': [],
+    'required-stages-completed': [],
+    'selected-stage-completed': ['stage'],
+    'selected-stage-exited': ['stage'],
+    'selected-tasks-completed': ['tasks'],
+    'current-stage-entered': [],
+    adhoc: [],
+    'runs-sequentially': [],
+    'user-selected-stage': [],
+    'wait-for-connector': ['connector'],
+    'sla-status-change': ['sla', 'escalation'],
+    'api-event': ['businessEvent'],
+};
+/**
+ * Report an unknown rule kind, or each option the rule's kind does not read.
+ * Options set to `undefined` count as absent.
+ *
+ * @param r - The rule as built (`rule(type, opts)` or a literal).
+ * @returns The problems, empty when the rule is well formed.
+ */
+export function ruleShapeProblems(r) {
+    const kind = r.rule;
+    const own = ownEntry(RULE_OPTIONS, kind);
+    if (!own)
+        return [
+            {
+                code: 'UNKNOWN_RULE',
+                message: `Unknown rule "${kind}" — the rule kinds are ${Object.keys(RULE_OPTIONS).map((k) => `"${k}"`).join(', ')}.`,
+            },
+        ];
+    const allowed = [...own, ...COMMON];
+    return Object.keys(r)
+        .filter((key) => key !== 'rule' && r[key] !== undefined)
+        .filter((key) => !allowed.includes(key))
+        .map((key) => ({
+        code: 'RULE_UNKNOWN_OPTION',
+        message: `Rule "${kind}" does not take option "${key}", so it would be dropped from the caseplan — ` +
+            `"${kind}" takes ${allowed.map((k) => `"${k}"`).join(', ')}.` +
+            (kind === 'api-event' ? ` Name the event with { businessEvent: '<name>' }.` : ''),
+    }));
+}