@uipath/maestro-builder-sdk 6.11.6 → 6.12.0

package/dist/bpmn/serialize.d.ts

@@ -1,4 +1,4 @@
-import { type BuiltBpmn } from './bpmn-sdk.js';
+import { type BuiltBpmn, type BpmnNode, type BpmnVarDecl } from './bpmn-sdk.js';
 import type { Library } from '../core/library.js';
 import type { Bindings } from '../core/bindings.js';
 /** Optional wiring for connector service tasks. */
@@ -26,3 +26,67 @@ export declare function serialize(built: BuiltBpmn, opts?: BpmnSerializeOpts): P
  */
 export declare function finalizeBpmnXml(xml: string): string;
 export declare function processId(id: string): string;
+/**
+ * The variable declarations a scope's output-bearing nodes imply.
+ *
+ * A connector's or typed node's output row names a variable the author never declared
+ * (`<id>_response`, `<id>_Error`). Studio Web carries a matching variable for every
+ * such row, and without it the canvas validator warns `MISSING_ROOT_VARIABLE`; declaring
+ * them keeps the artifact indistinguishable from a designed one. A SCRIPT task's
+ * `outputs` need it more than that: `uip maestro bpmn validate` does NOT treat a
+ * `BPMN.ScriptTask` row's `var` as a declaration — a `vars.<output>` read downstream is
+ * `VARIABLE_DOES_NOT_EXIST` on 1.202 and 1.203 alike (measured on a gateway condition
+ * reading a script's `confidence`) — so those rows get one too, typed `string` like the
+ * row itself. Author-declared names win: an explicit `.var()` for the same name is left
+ * exactly as written.
+ *
+ * Each derived declaration belongs to the node whose row fills it (`elementId`), the
+ * way the product declares a node's own outputs. `decompile` recognises exactly this
+ * shape (`derivedVariableIds`) and does not echo it, so the two sides stay a round trip.
+ */
+export declare function implicitNodeVars(nodes: BpmnNode[], declared: BpmnVarDecl[]): BpmnVarDecl[];
+/**
+ * The `resourceKey` each author-declared FOLDER binding should carry: the key of the
+ * connection it is the companion of.
+ *
+ * A `folderKey` binding is not a resource of its own. Every real export writes the
+ * pair as `ConnectionId` binding `{resourceKey: <connection>, default: <connection>}`
+ * and `folderKey` binding `{resourceKey: <connection>, default: <folder>}` — the folder
+ * is where the CONNECTION is resolved, so its resource key is the connection's. A
+ * binding declared through `.binding('f', { propertyAttribute: 'folderKey', value })`
+ * used to collapse `resourceKey` onto `value`, the folder's own key, and
+ * `uip maestro bpmn validate` reported `MISSING_BINDING` for it — on every process the
+ * run-6 agents authored against Data Fabric or Test Manager.
+ *
+ * Pairing comes from the nodes: a node whose context reads `=bindings.<c>` as its
+ * `connection` and `=bindings.<f>` as its `folderKey` pairs `f` with `c`. A folder no
+ * node pairs falls back to the only `ConnectionId` binding when there is exactly one.
+ * An explicit `resourceKey` on the declaration is never overridden.
+ */
+export declare function folderCompanionKeys(built: BuiltBpmn, sink: Map<string, Record<string, unknown>>): Map<string, string>;
+/**
+ * Where an unscoped PUBLIC declaration belongs at the top level of a process.
+ *
+ * Every real artifact agrees: across the 97 Studio Web exports and converter outputs
+ * measured (`research/bpmn-roundtrip/corpus/`, the run-6 `v1` arm), all 107 public
+ * `uipath:input` declarations are scoped to the process's manual START event and all
+ * 37 `uipath:output` declarations to the END event whose mapping writes them — none to
+ * the process. The engine does not need it (`BpmnDataManager.EvaluateProcessVariables`
+ * seeds every declaration into one variables scope by id, and an expression resolves
+ * `vars.<id>` there whatever the declaration's `elementId`), but the canvas, the
+ * entry-point derivation and the graders that read a process's contract do: a process
+ * input is "the start event's input". Until this, the SDK wrote the process id, which
+ * validated and ran and was the one placement nothing else on the platform produces —
+ * cluster D of docs/BPMN_AUTHORING_ERGONOMICS_DESIGN.md §1b.
+ *
+ * The rule, mirrored by `bpmn-decompile` so an unscoped declaration round-trips without
+ * an explicit `elementId`:
+ *  - `input`  → the one root start event with no event definition and no trigger,
+ *               when there is exactly one; else the process.
+ *  - `output` → the one root end event whose payload writes `var="<id>"`; else the one
+ *               root end event, when there is exactly one; else the process.
+ *  - `inputOutput` → the process (an internal variable is process-level state; the
+ *               engine's debug variables report lists exactly those).
+ * An explicit `elementId` always wins, and `null` still means "write none".
+ */
+export declare function publicDeclarationScope(nodes: BpmnNode[], processId: string): (v: BpmnVarDecl) => string;

package/dist/bpmn/serialize.js

@@ -104,13 +104,14 @@ export async function serialize(built, opts = {}) {
     // effect — then assemble the process extensionElements from the result.
     const flowElements = buildScope(ctx, built.nodes, built.flows);
     const processExt = [];
-    const varsExt = buildVariablesExt(ctx, rootVars);
+    const varsExt = buildVariablesExt(ctx, rootVars, built.id, publicDeclarationScope(built.nodes, built.id));
     if (varsExt)
         processExt.push(varsExt);
     // Author-declared bindings first, then the ones connector wiring derived —
     // one `uipath:bindings` block either way, since the runtime reads one registry.
     // An author declaration wins on an id collision: it is the more specific intent.
     const declaredIds = new Set(built.bindings.map((b) => b.id));
+    const companionKey = folderCompanionKeys(built, ctx.bindingSink);
     const bindingRows = [
         ...built.bindings.map((b) => ({
             id: b.id,
@@ -118,7 +119,7 @@ export async function serialize(built, opts = {}) {
             type: 'string',
             resource: b.resource,
             resourceSubType: b.resourceSubType,
-            resourceKey: b.resourceKey,
+            resourceKey: b.resourceKey ?? companionKey.get(b.id) ?? b.default,
             default: b.default,
             propertyAttribute: b.propertyAttribute,
         })),
@@ -286,6 +287,11 @@ function createNode(ctx, n) {
                 return el;
             }
             const el = m.create(`bpmn:${cap(n.kind)}`, { id: n.id, name: n.name });
+            // Only the exception is written: BPMN's default is interrupting, and an
+            // `isInterrupting="true"` the author never asked for would change the bytes
+            // of every existing process.
+            if (n.kind === 'startEvent' && n.interrupting === false)
+                el.isInterrupting = false;
             attachExtensionPayload(ctx, el, n.payload);
             const def = eventDefinition(ctx, n.event);
             if (def)
@@ -326,6 +332,8 @@ function createNode(ctx, n) {
                 context: n.context,
                 contextRows: n.contextRows,
                 inputs: n.inputs,
+                inputRows: n.inputRows,
+                spec: n.spec,
                 typeVersion: n.typeVersion,
                 inputSchema: n.inputSchema,
                 outputVar: n.outputVar,
@@ -463,8 +471,12 @@ function createScriptTask(ctx, n) {
         // these as a sequence and both orders validate, but matching the product's
         // means an imported script task round-trips without a reordered diff, which
         // the brownfield `edit/*` eval tasks grade on.
+        //
+        // The VALUE is the node's, not a constant: it selects the runtime's result shape
+        // (v2+ wraps the return value, v1 spreads it), so stamping every script task `v3`
+        // silently changed what an imported v1 task's outputs resolved to.
         extensionElements: m.create('bpmn:ExtensionElements', {
-            values: [mapping, m.create('uipath:ScriptVersion', { value: 'v3' })],
+            values: [mapping, m.create('uipath:ScriptVersion', { value: n.scriptVersion })],
         }),
         script: n.script,
     });
@@ -489,7 +501,13 @@ function createSubProcess(ctx, n) {
     if (n.triggeredByEvent)
         props.triggeredByEvent = true;
     const values = [];
-    const varsExt = buildVariablesExt(ctx, [...n.variables, ...implicitNodeVars(n.nodes, n.variables)]);
+    // The ENCLOSING scopes' declarations count as taken too. Passing only the
+    // sub-process's own meant a script task inside it re-declared an output variable the
+    // root already declares — same id, twice in one document, which is the
+    // DUPLICATE_DOCUMENT_ID the emitter goes out of its way to avoid everywhere else
+    // (the XML parser drops the second element that reuses an id).
+    const enclosing = [...n.variables, ...[...ctx.varType.keys()].map((id) => ({ id }))];
+    const varsExt = buildVariablesExt(ctx, [...n.variables, ...implicitNodeVars(n.nodes, enclosing)], n.id);
     if (varsExt)
         values.push(varsExt);
     if (values.length)
@@ -594,27 +612,34 @@ function assignmentSource(value) {
  * The variable declarations a scope's output-bearing nodes imply.
  *
  * A connector's or typed node's output row names a variable the author never declared
- * (`<id>_response`, `<id>_Error`). The reference to one already RESOLVES without
- * this — the platform treats an output's `var` as a declaration — but Studio Web
- * also carries a matching root variable, and without it the canvas validator
- * warns `MISSING_ROOT_VARIABLE`. Declaring them keeps the artifact
- * indistinguishable from a designed one. Author-declared names win: an explicit
- * `.var()` for the same name is left exactly as written.
+ * (`<id>_response`, `<id>_Error`). Studio Web carries a matching variable for every
+ * such row, and without it the canvas validator warns `MISSING_ROOT_VARIABLE`; declaring
+ * them keeps the artifact indistinguishable from a designed one. A SCRIPT task's
+ * `outputs` need it more than that: `uip maestro bpmn validate` does NOT treat a
+ * `BPMN.ScriptTask` row's `var` as a declaration — a `vars.<output>` read downstream is
+ * `VARIABLE_DOES_NOT_EXIST` on 1.202 and 1.203 alike (measured on a gateway condition
+ * reading a script's `confidence`) — so those rows get one too, typed `string` like the
+ * row itself. Author-declared names win: an explicit `.var()` for the same name is left
+ * exactly as written.
+ *
+ * Each derived declaration belongs to the node whose row fills it (`elementId`), the
+ * way the product declares a node's own outputs. `decompile` recognises exactly this
+ * shape (`derivedVariableIds`) and does not echo it, so the two sides stay a round trip.
  */
-function implicitNodeVars(nodes, declared) {
+export function implicitNodeVars(nodes, declared) {
     const taken = new Set(declared.map((v) => v.id));
     const out = [];
-    const claim = (id) => {
+    const claim = (id, ownerId, type = 'object') => {
         if (!id || taken.has(id))
             return;
         taken.add(id);
-        out.push({ id, name: id, type: 'object', direction: 'inputOutput' });
+        out.push({ id, name: id, type, direction: 'inputOutput', elementId: ownerId });
     };
     for (const n of nodes) {
         if (n.kind === 'connector') {
             const { response, error } = connectorOutputVars(n);
-            claim(response);
-            claim(error);
+            claim(response, n.id);
+            claim(error, n.id);
         }
         else if (n.kind === 'typed') {
             // Shared with the expression checker rather than repeated here. Repeating it is
@@ -623,25 +648,94 @@ function implicitNodeVars(nodes, declared) {
             // side vanishes from the recompiled process. Measured on a Slack connector —
             // `send_Error` was declared in the original and absent after the round trip.
             for (const varId of typedNodeDeclaredVars(n))
-                claim(varId);
+                claim(varId, n.id);
         }
         else if (n.kind === 'connectorEvent' || n.kind === 'externalTask') {
             // Same reason as the typed and connector arms: the node's output rows
             // reference variables the process must declare, or the canvas validator
             // reports MISSING_ROOT_VARIABLE.
-            claim(intsvcOutputVar(n));
+            claim(intsvcOutputVar(n), n.id);
             for (const varId of Object.keys(n.outputs ?? {}))
-                claim(varId);
+                claim(varId, n.id);
         }
         else if (n.kind === 'startEvent' && n.trigger) {
             // A trigger's payload row writes a variable like any typed node's, so it
             // needs the same implicit declaration — without it the row references a
             // variable the process never declares (MISSING_ROOT_VARIABLE).
-            claim(typedNodeOutputVar(n.id, n.trigger.type, n.trigger.outputVar));
+            claim(typedNodeOutputVar(n.id, n.trigger.type, n.trigger.outputVar), n.id);
+        }
+        else if (n.kind === 'scriptTask') {
+            // `object` (emitted as `json`), not `string`. Under the v3 contract a script
+            // returns `{ response: <whatever it returned> }`, so an output nobody declared
+            // holds arbitrary JSON — declaring a number or an object as `string` is the
+            // mis-declaration this fallback exists to avoid. An output the AUTHOR declared
+            // keeps its own type: `claim` skips an id already taken.
+            for (const varId of Object.keys(n.outputs))
+                claim(varId, n.id);
         }
     }
     return out;
 }
+/**
+ * The `resourceKey` each author-declared FOLDER binding should carry: the key of the
+ * connection it is the companion of.
+ *
+ * A `folderKey` binding is not a resource of its own. Every real export writes the
+ * pair as `ConnectionId` binding `{resourceKey: <connection>, default: <connection>}`
+ * and `folderKey` binding `{resourceKey: <connection>, default: <folder>}` — the folder
+ * is where the CONNECTION is resolved, so its resource key is the connection's. A
+ * binding declared through `.binding('f', { propertyAttribute: 'folderKey', value })`
+ * used to collapse `resourceKey` onto `value`, the folder's own key, and
+ * `uip maestro bpmn validate` reported `MISSING_BINDING` for it — on every process the
+ * run-6 agents authored against Data Fabric or Test Manager.
+ *
+ * Pairing comes from the nodes: a node whose context reads `=bindings.<c>` as its
+ * `connection` and `=bindings.<f>` as its `folderKey` pairs `f` with `c`. A folder no
+ * node pairs falls back to the only `ConnectionId` binding when there is exactly one.
+ * An explicit `resourceKey` on the declaration is never overridden.
+ */
+export function folderCompanionKeys(built, sink) {
+    const keyOf = new Map();
+    const connectionIds = [];
+    const isConnectionId = (attr) => String(attr ?? '').toLowerCase() === 'connectionid';
+    for (const b of built.bindings) {
+        const key = b.resourceKey ?? b.default;
+        if (key !== undefined)
+            keyOf.set(b.id, key);
+        if (isConnectionId(b.propertyAttribute))
+            connectionIds.push(b.id);
+    }
+    for (const b of sink.values()) {
+        const key = b.resourceKey ?? b.default;
+        if (key !== undefined && !keyOf.has(b.id))
+            keyOf.set(b.id, key);
+        if (isConnectionId(b.propertyAttribute) && !connectionIds.includes(b.id))
+            connectionIds.push(b.id);
+    }
+    const bindingId = (value) => typeof value === 'string' && value.startsWith('=bindings.') ? value.slice('=bindings.'.length) : undefined;
+    const pairs = new Map();
+    for (const n of allNodes(built.nodes)) {
+        if (n.kind !== 'typed')
+            continue;
+        const view = { ...n.context };
+        for (const row of n.contextRows ?? [])
+            view[row.name] = row.value ?? row.body;
+        const connection = bindingId(view.connection ?? view.connectionId);
+        const folder = bindingId(view.folderKey);
+        if (connection && folder && !pairs.has(folder))
+            pairs.set(folder, connection);
+    }
+    const out = new Map();
+    for (const b of built.bindings) {
+        if (String(b.propertyAttribute ?? '').toLowerCase() !== 'folderkey' || b.resourceKey !== undefined)
+            continue;
+        const companion = pairs.get(b.id) ?? (connectionIds.length === 1 ? connectionIds[0] : undefined);
+        const key = companion !== undefined ? keyOf.get(companion) : undefined;
+        if (key !== undefined)
+            out.set(b.id, key);
+    }
+    return out;
+}
 /**
  * `uipath:retry` — a retry policy, as a sibling of the activity's mapping/activity
  * element rather than inside it, which is why it works on every activity kind.
@@ -700,8 +794,21 @@ function buildLoopCharacteristics(ctx, loop) {
 function defaultAttr(value, mappedType) {
     return mappedType === 'json' ? JSON.stringify(value) : String(value);
 }
-/** A `uipath:variables` extension element grouping declarations by direction. */
-function buildVariablesExt(ctx, vars) {
+/**
+ * A `uipath:variables` extension element grouping declarations by direction.
+ *
+ * `ownerId` is the scope the block sits in — the process or sub-process id — and is
+ * what a declaration with no `elementId` of its own is written as belonging to. The
+ * product writes every scope-level variable that way, and `uip maestro bpmn validate`
+ * 1.203 refuses one without it (`ROOT_VARIABLE_MISSING_ELEMENT_ID`: "no expression can
+ * resolve it"); a declaration inside a sub-process is resolved by both 1.202 and 1.203
+ * only when it carries one (measured: `vars.decision` declared in the sub-process block
+ * was `VARIABLE_DOES_NOT_EXIST` until `elementId` named the sub-process). `null` means
+ * the author — in practice `decompile`, echoing an older export — wants none written.
+ */
+function buildVariablesExt(ctx, vars, ownerId, 
+/** The default scope of a declaration the author left unscoped; the owner when absent. */
+scopeOf = () => ownerId) {
     const { m } = ctx;
     if (!vars.length)
         return undefined;
@@ -711,7 +818,7 @@ function buildVariablesExt(ctx, vars) {
             id: v.id,
             name: v.name,
             type: mapType(v.type),
-            elementId: v.elementId,
+            elementId: v.elementId === null ? undefined : (v.elementId ?? scopeOf(v)),
             default: v.default === undefined ? undefined : defaultAttr(v.default, mapType(v.type)),
             // Carried, never interpreted — a schema field this SDK does not model survives.
             body: schemaBody(ctx, v.schema),
@@ -728,6 +835,46 @@ function buildVariablesExt(ctx, vars) {
         props.output = groups.output;
     return m.create('uipath:Variables', props);
 }
+/**
+ * Where an unscoped PUBLIC declaration belongs at the top level of a process.
+ *
+ * Every real artifact agrees: across the 97 Studio Web exports and converter outputs
+ * measured (`research/bpmn-roundtrip/corpus/`, the run-6 `v1` arm), all 107 public
+ * `uipath:input` declarations are scoped to the process's manual START event and all
+ * 37 `uipath:output` declarations to the END event whose mapping writes them — none to
+ * the process. The engine does not need it (`BpmnDataManager.EvaluateProcessVariables`
+ * seeds every declaration into one variables scope by id, and an expression resolves
+ * `vars.<id>` there whatever the declaration's `elementId`), but the canvas, the
+ * entry-point derivation and the graders that read a process's contract do: a process
+ * input is "the start event's input". Until this, the SDK wrote the process id, which
+ * validated and ran and was the one placement nothing else on the platform produces —
+ * cluster D of docs/BPMN_AUTHORING_ERGONOMICS_DESIGN.md §1b.
+ *
+ * The rule, mirrored by `bpmn-decompile` so an unscoped declaration round-trips without
+ * an explicit `elementId`:
+ *  - `input`  → the one root start event with no event definition and no trigger,
+ *               when there is exactly one; else the process.
+ *  - `output` → the one root end event whose payload writes `var="<id>"`; else the one
+ *               root end event, when there is exactly one; else the process.
+ *  - `inputOutput` → the process (an internal variable is process-level state; the
+ *               engine's debug variables report lists exactly those).
+ * An explicit `elementId` always wins, and `null` still means "write none".
+ */
+export function publicDeclarationScope(nodes, processId) {
+    const manualStarts = nodes.filter((n) => n.kind === 'startEvent' && n.event === undefined && n.trigger === undefined);
+    const ends = nodes.filter((n) => n.kind === 'endEvent');
+    return (v) => {
+        if (v.direction === 'input')
+            return manualStarts.length === 1 ? manualStarts[0].id : processId;
+        if (v.direction === 'output') {
+            const writers = ends.filter((e) => (e.payload?.outputRows ?? []).some((r) => r.var === v.id));
+            if (writers.length === 1)
+                return writers[0].id;
+            return ends.length === 1 ? ends[0].id : processId;
+        }
+        return processId;
+    };
+}
 // ─── Small helpers ────────────────────────────────────────────────────────────
 function cap(s) {
     return s.charAt(0).toUpperCase() + s.slice(1);

package/dist/bpmn/typed-node.d.ts

@@ -108,11 +108,12 @@ export declare function registryTypeNames(): string[];
  * `FLOW_SDK_BPMN_REGISTRY_FALLBACK=0` to keep resolution snapshot-only.
  *
  * @param type - The extension type, e.g. `'Intsvc.UnifiedHttpRequest'`.
+ * @param inline - A spec supplied by the author, which is used as is.
  * @returns Its emission spec.
  * @throws If the type is in neither the snapshot nor the registry — which means a
  * typo, or no `uip` to ask.
  */
-export declare function registryType(type: string): RegistryTypeSpec;
+export declare function registryType(type: string, inline?: RegistryTypeSpec): RegistryTypeSpec;
 /** True when the snapshot itself carries the type — no tenant needed to emit it. */
 export declare function isSnapshotType(type: string): boolean;
 /**
@@ -138,6 +139,7 @@ export declare function isSnapshotType(type: string): boolean;
 export declare const REGISTRY_GAPS: Record<string, {
     resourceSubType?: string;
     extraContext?: string[];
+    requiredContext?: string[];
     outputRowsFixed?: boolean;
     notEnforcedInputs?: string[];
 }>;
@@ -181,6 +183,29 @@ export interface TypedContextRow {
     /** The row's `required` attribute — 11 context rows in the corpus carry one. */
     required?: boolean;
 }
+/**
+ * One `uipath:input` payload row spelled out — the `separateInputs` counterpart of
+ * {@link TypedContextRow}.
+ *
+ * `inputs` is a name→value record, so a row's `type` and `target` are derived: the
+ * registry's declaration when the type has one, else `json` for a structured value,
+ * `string` for a scalar, and the KEY as the target. A real artifact often carries what
+ * that cannot express — a connector's `<uipath:input name="start" type="string"
+ * value="0" target="query"/>` has a target that is not its name, and a type the
+ * registry does not declare. These rows carry their own.
+ */
+export interface TypedInputRow {
+    /** Row name — the wire parameter name, e.g. `entityName` or `body`. */
+    name: string;
+    /** The row's type. Defaults to `string`; `json` rows carry their value in `body`. */
+    type?: string;
+    /** The `target` attribute — `path`, `query`, `body`, `file`, `bodyField`, … */
+    target?: string;
+    /** The `value` attribute, for a scalar row. Omitted entirely when absent. */
+    value?: string;
+    /** The row's CDATA body, for a `json` row — the value itself, or a string when the exact bytes matter. */
+    body?: unknown;
+}
 export interface TypedOutputRow {
     /** Row name, e.g. `response` or `Error`. */
     name: string;
@@ -216,6 +241,8 @@ export interface TypedNodeInput {
     contextRows?: TypedContextRow[];
     /** The payload, shaped per the type's `inputPattern`. */
     inputs?: Record<string, unknown>;
+    /** Payload rows spelled out, replacing `inputs` — see {@link TypedInputRow}. */
+    inputRows?: TypedInputRow[];
     /** The `uipath:type` `version` attribute — see `ActivityNodeOpts.typeVersion`. */
     typeVersion?: string;
     /** The `uipath:inputSchema` body inside `uipath:context` — see `ActivityNodeOpts.inputSchema`. */
@@ -265,9 +292,13 @@ export interface TypedNodeInput {
      * what it had, breaks a byte-exact round-trip. `bpmn-decompile` sets this.
      */
     contextVerbatim?: boolean;
+    /** The type's emission spec, supplied inline — see `ActivityNodeOpts.spec`. */
+    spec?: RegistryTypeSpec;
 }
 /** The variable a typed node's output row writes, or `undefined` when it has none. */
-export declare function typedNodeOutputVar(id: string, type: string, outputVar?: string): string | undefined;
+export declare function typedNodeOutputVar(id: string, type: string, outputVar?: string, inline?: RegistryTypeSpec): string | undefined;
+/** `uipath:input` payload rows exactly as the caller spelled them, deriving nothing. */
+export declare function verbatimInputRows(m: BpmnModdle, rows: TypedInputRow[]): El[];
 /**
  * Emit a registry-backed typed node.
  *
@@ -320,7 +351,7 @@ export declare function createExtensionPayload(m: BpmnModdle, type: string, rows
  * @param type - The extension type.
  * @returns Its fields that must be bound, with the target each binding needs.
  */
-export declare function bindingRequiredFields(type: string): RegistryContextField[];
+export declare function bindingRequiredFields(type: string, inline?: RegistryTypeSpec): RegistryContextField[];
 /**
  * Required context fields the author left unset and the registry cannot default.
  *
@@ -332,7 +363,7 @@ export declare function bindingRequiredFields(type: string): RegistryContextFiel
  * @param context - The context values the author supplied.
  * @returns The names of required fields with no value and no default.
  */
-export declare function missingRequiredContext(type: string, context?: Record<string, unknown>): string[];
+export declare function missingRequiredContext(type: string, context?: Record<string, unknown>, inline?: RegistryTypeSpec): string[];
 /**
  * Required PAYLOAD fields the author left unset.
  *
@@ -357,7 +388,7 @@ export declare function missingRequiredInputs(type: string, inputs?: Record<stri
  * genuinely does not spell (it writes `connection`). Reading both makes this
  * agree with the CLI instead of guessing on either side of it.
  */
-context?: Record<string, unknown>): string[];
+context?: Record<string, unknown>, inline?: RegistryTypeSpec): string[];
 /**
  * Whether this type's required payload fields are UNSATISFIABLE on the wire.
  *
@@ -389,5 +420,5 @@ context?: Record<string, unknown>): string[];
  * @param type - The extension type.
  * @returns The required payload field names that cannot be expressed, or `[]`.
  */
-export declare function unsatisfiableRequiredInputs(type: string): string[];
+export declare function unsatisfiableRequiredInputs(type: string, inline?: RegistryTypeSpec): string[];
 export {};