@uipath/maestro-builder-sdk 6.16.14 → 6.17.0

package/dist/core/actions.d.ts

@@ -981,21 +981,48 @@ export type DelayInputs = {
     /** Impossible together with `until` — a delay waits one way or the other. */
     duration?: never;
 };
+/**
+ * Where a process resource lives: deployed to an Orchestrator folder
+ * (`'published'`, the default) or a sibling project of the SAME solution
+ * (`'in-solution'`). Shared by `rpaWorkflow`, `agenticProcess` and `agent`.
+ */
+export type ProcessLocation = 'published' | 'in-solution';
 export interface RpaWorkflowInputs {
     /**
      * The published process's release key (a GUID). It becomes part of the node's
      * type, `uipath.core.rpa-workflow.<key>`. Find it with
      * `uip or processes list --all-folders --process-type Process` (the row's `Key`)
      * or `uip maestro flow registry search "uipath.core.rpa-workflow"`.
+     *
+     * For an in-solution sibling it is `resource.key` from
+     * `resources/solution_folder/process/process/<project>.json` — the suffix of the
+     * node type `uip maestro flow registry list --local` shows.
      */
     key: string;
     /** The process's name in Orchestrator — e.g. `'RPA Workflow'`. */
     name: string;
+    /**
+     * Where the process lives. `'published'` (the default) is a process deployed
+     * to `folderPath`. `'in-solution'` is a sibling RPA project of the same
+     * solution: it needs `projectId` and no `folderPath`.
+     */
+    location?: ProcessLocation;
     /**
      * The Orchestrator folder holding the process — e.g.
-     * `'Shared/uipath-maestro-flow/ProjectEuler RPA'`.
+     * `'Shared/uipath-maestro-flow/ProjectEuler RPA'`. Required for a published
+     * process; omit it for an in-solution sibling.
+     *
+     * @enforcedBy RPA_NO_FOLDER A published process needs its folder.
      */
-    folderPath: string;
+    folderPath?: string;
+    /**
+     * The sibling RPA project's `resource.projectKey`, read from
+     * `resources/solution_folder/process/process/<project>.json`. Required only
+     * when `location` is `'in-solution'`.
+     *
+     * @enforcedBy RPA_LOCAL_NO_PROJECT_ID An in-solution process needs its project id.
+     */
+    projectId?: string;
     /**
      * The PROCESS's own input arguments, by its own argument names (e.g.
      * `{ problemId: 123 }`). Not a fixed schema — every process declares its own,
@@ -1101,11 +1128,33 @@ interface AgenticProcessInputsBase {
     key: string;
     /** The process's name in Orchestrator — e.g. `'ProcurementProcess'`. */
     name: string;
+    /**
+     * Where the process lives. `'published'` (the default) is a process deployed
+     * to `folderPath`. `'in-solution'` is a sibling Flow of the same solution, so
+     * it needs `form: 'flow'`, `projectId` and no `folderPath`; `key` is the
+     * sibling's `resource.key` from `resources/solution_folder/process/flow/<project>.json`.
+     * Only the Flow form has been run in-solution; `'bpmn'` and `'case'` siblings
+     * are refused until they are.
+     *
+     * @enforcedBy AGENTIC_LOCAL_FORM_UNVERIFIED In-solution is supported for `form: 'flow'` only.
+     */
+    location?: ProcessLocation;
     /**
      * The Orchestrator folder holding it — e.g.
-     * `'Shared/uipath-agents/ProcurementProcess'`.
+     * `'Shared/uipath-agents/ProcurementProcess'`. Required for a published
+     * process; omit it for an in-solution sibling.
+     *
+     * @enforcedBy AGENTIC_NO_FOLDER A published process needs its folder.
      */
-    folderPath: string;
+    folderPath?: string;
+    /**
+     * The sibling project's `resource.projectKey`, read from the same resource
+     * file as `key` (`resources/solution_folder/process/flow/<project>.json`).
+     * Required only when `location` is `'in-solution'`.
+     *
+     * @enforcedBy AGENTIC_LOCAL_NO_PROJECT_ID An in-solution process needs its project id.
+     */
+    projectId?: string;
     /**
      * The PROCESS's own input arguments, by its own argument names (e.g.
      * `{ productId: 1 }`). Not a fixed schema — every agentic process declares its
@@ -1167,7 +1216,7 @@ export type AgenticProcessInputs = AgenticProcessInputsBase & AgenticProcessComp
  * resource. Display-only — see {@link AgentInputs.flavour}.
  */
 export type AgentFlavour = 'coded' | 'lowcode';
-export type AgentLocation = 'published' | 'in-solution';
+export type AgentLocation = ProcessLocation;
 export interface AgentInputs {
     /**
      * The agent resource key (a GUID). It becomes the node's TYPE,
@@ -1526,15 +1575,15 @@ export interface InlineAgentInputs {
     maxIterations?: number;
     /**
      * The harness the agent runs on — `'standard'` (the default) or
-     * `'advanced'`. Naming it selects the node's **1.3** definition (the
-     * registry's current, which adds the field); omitting it emits the 1.2
-     * definition byte-identically.
+     * `'advanced'`, written to the `agent.json`'s `settings.mode`. It does not
+     * change the node's version: every inline agent emits the bundle's newest
+     * `uipath.agent.autonomous` definition (1.4).
      */
     mode?: 'standard' | 'advanced';
     /**
      * Safety rails over the agent's inputs, outputs, LLM calls and tools — the
-     * platform's own array shape ({@link AgentGuardrail}), carried on the node
-     * (its 1.2 definition already declares the input) and in the `agent.json`.
+     * platform's own array shape ({@link AgentGuardrail}), carried in the
+     * `agent.json` (every bundled definition declares the input).
      *
      * ```ts
      * guardrails: [{
@@ -1550,8 +1599,8 @@ export interface InlineAgentInputs {
     guardrails?: AgentGuardrail[];
     /**
      * Attach an episodic memory so the agent learns from past runs — one
-     * {@link AgentMemoryRef}, wired to the agent's `memory` handle (its 1.4
-     * definition; naming one selects it).
+     * {@link AgentMemoryRef}, wired to the agent's `memory` handle (declared by
+     * the bundled 1.4 definition, which every inline agent uses).
      */
     memory?: AgentMemoryRef;
     /**
@@ -1764,9 +1813,9 @@ export interface HttpRequestToolRef {
  * An episodic memory the agent learns from across runs, wired to the agent's
  * own `memory` handle. Node type
  * `uipath.agent.resource.memory.<name-slug>.<id-slug>`, minted exactly as the
- * platform's mapper does. Naming one selects the agent's **1.4** definition
- * (which adds the handle) — transcribed from workbench source; the tenant
- * registry serves 1.3 (same availability note as do-while).
+ * platform's mapper does. The handle is LOCAL content on the bundled
+ * `uipath.agent.autonomous@1.4` (#431): the registry's own 1.4 declares no
+ * `memory` handle, so `check` refuses this today (AGENT_MEMORY_NOT_AUTHORABLE).
  */
 export interface AgentMemoryRef {
     /** The memory's display name on the tenant. */
@@ -1960,7 +2009,12 @@ export interface EscalationRef {
         key: string;
         /** The app's name, e.g. `'ContentReviewApp'`. */
         name: string;
-        /** The Orchestrator folder the app lives in. */
+        /**
+         * The Orchestrator folder the app lives in, e.g. `'Shared/Approvals'`.
+         * Omit it for an app that ships in this solution: compile then writes
+         * `'solution_folder'`, the `Folder` `uip solution resources list` reports
+         * for a solution-internal app.
+         */
         folderPath?: string;
         /** The fields the agent hands the reviewer — becomes the app's `inputSchema`. */
         inputs?: Record<string, InlineAgentFieldType>;

package/dist/core/agentic-process-forms.d.ts

@@ -0,0 +1,51 @@
+/**
+ * The three published forms under the Agentic Process umbrella (design §2.1).
+ * One public factory, three wire identities — transcribed from flow-v1's
+ * `RESOURCE_TYPE_METADATA` (ProcessOrchestration / Flow / CaseManagement):
+ * node-type segment, category, icon, resource subtype, `orchestratorType`
+ * (`resourceType.toLowerCase()`, per `createModel`), and the sync/async
+ * service-type pair. All three declare the fire-and-forget switch.
+ *
+ * `solutionFolder` is the folder under `resources/solution_folder/process/`
+ * that holds an in-solution sibling's resource file (e.g. a sibling Flow lands in
+ * `process/flow/Notifier.json`). The solution writer names it
+ * `toLowerFirstChar(resource.type)`: `@uipath/resource-builder-sdk`
+ * `MultiFileSolutionDefinitionProvider.buildResourceRelativePath`, with the
+ * process types `flow`, `processOrchestration` and `caseManagement` from that
+ * package's resource-type catalog.
+ *
+ * Shared by the serializer (which emits the node) and `check` (which names the
+ * resource file in `AGENTIC_LOCAL_NO_PROJECT_ID`), so the two can never disagree
+ * about what a form is.
+ */
+export declare const AGENTIC_PROCESS_FORMS: {
+    readonly bpmn: {
+        readonly prefix: "uipath.core.agentic-process.";
+        readonly category: "agentic-process";
+        readonly icon: "agentic-process";
+        readonly resourceSubType: "ProcessOrchestration";
+        readonly orchestratorType: "processorchestration";
+        readonly serviceType: "Orchestrator.StartAgenticProcess";
+        readonly solutionFolder: "processOrchestration";
+    };
+    readonly flow: {
+        readonly prefix: "uipath.core.flow.";
+        readonly category: "flow";
+        readonly icon: "flow-project";
+        readonly resourceSubType: "Flow";
+        readonly orchestratorType: "flow";
+        readonly serviceType: "Orchestrator.StartFlowProcess";
+        readonly solutionFolder: "flow";
+    };
+    readonly case: {
+        readonly prefix: "uipath.core.case-management.";
+        readonly category: "case-management";
+        readonly icon: "case-management";
+        readonly resourceSubType: "CaseManagement";
+        readonly orchestratorType: "casemanagement";
+        readonly serviceType: "Orchestrator.StartCaseMgmtProcess";
+        readonly solutionFolder: "caseManagement";
+    };
+};
+/** An `agenticProcess` form: `'bpmn' | 'flow' | 'case'`. */
+export type AgenticProcessForm = keyof typeof AGENTIC_PROCESS_FORMS;

package/dist/core/agentic-process-forms.js

@@ -0,0 +1,49 @@
+/**
+ * The three published forms under the Agentic Process umbrella (design §2.1).
+ * One public factory, three wire identities — transcribed from flow-v1's
+ * `RESOURCE_TYPE_METADATA` (ProcessOrchestration / Flow / CaseManagement):
+ * node-type segment, category, icon, resource subtype, `orchestratorType`
+ * (`resourceType.toLowerCase()`, per `createModel`), and the sync/async
+ * service-type pair. All three declare the fire-and-forget switch.
+ *
+ * `solutionFolder` is the folder under `resources/solution_folder/process/`
+ * that holds an in-solution sibling's resource file (e.g. a sibling Flow lands in
+ * `process/flow/Notifier.json`). The solution writer names it
+ * `toLowerFirstChar(resource.type)`: `@uipath/resource-builder-sdk`
+ * `MultiFileSolutionDefinitionProvider.buildResourceRelativePath`, with the
+ * process types `flow`, `processOrchestration` and `caseManagement` from that
+ * package's resource-type catalog.
+ *
+ * Shared by the serializer (which emits the node) and `check` (which names the
+ * resource file in `AGENTIC_LOCAL_NO_PROJECT_ID`), so the two can never disagree
+ * about what a form is.
+ */
+export const AGENTIC_PROCESS_FORMS = {
+    bpmn: {
+        prefix: 'uipath.core.agentic-process.',
+        category: 'agentic-process',
+        icon: 'agentic-process',
+        resourceSubType: 'ProcessOrchestration',
+        orchestratorType: 'processorchestration',
+        serviceType: 'Orchestrator.StartAgenticProcess',
+        solutionFolder: 'processOrchestration',
+    },
+    flow: {
+        prefix: 'uipath.core.flow.',
+        category: 'flow',
+        icon: 'flow-project',
+        resourceSubType: 'Flow',
+        orchestratorType: 'flow',
+        serviceType: 'Orchestrator.StartFlowProcess',
+        solutionFolder: 'flow',
+    },
+    case: {
+        prefix: 'uipath.core.case-management.',
+        category: 'case-management',
+        icon: 'case-management',
+        resourceSubType: 'CaseManagement',
+        orchestratorType: 'casemanagement',
+        serviceType: 'Orchestrator.StartCaseMgmtProcess',
+        solutionFolder: 'caseManagement',
+    },
+};

package/dist/core/binding-messages.d.ts

@@ -4,6 +4,11 @@ export declare const GUID_RE: RegExp;
 export type BindingRefusalCode = 'BINDING_SELF_NAME' | 'BINDING_UNDECLARED'
 /** An emitted definition's `<bindings.NAME>` placeholder has no `bindings[]` entry named NAME (#865). */
  | 'BINDING_PLACEHOLDER_UNRESOLVED'
+/**
+ * A custom node's definition references a `<bindings.NAME>` the contribution did not
+ * supply and the definition cannot close (no `resourceKey`, or no `values` row) (#942).
+ */
+ | 'CONTRIBUTION_BINDING_UNRESOLVED'
 /** Two steps on one connection disagree on which connector it belongs to (#866). */
  | 'CONNECTION_CONNECTOR_CONFLICT'
 /** A connector-bound node names no `connection` or no `folder` label (#890). */

package/dist/core/comment-text.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Text that is safe inside a generated `//` or `/* … *\/` comment.
+ *
+ * A decompiler or generator that splices an input string into a comment hands that
+ * string the rest of the comment: a line terminator ends a `//` comment, `*\/` ends a
+ * block, and whatever follows is CODE in a file `compile` later executes. Those are the
+ * only two ways out of a JavaScript comment, so replacing both (line terminators — LF,
+ * CR, U+2028, U+2029 — with one space, `*\/` with `* /`) is complete, not a denylist.
+ * The replacements are the ones registry/generators already used, so their output keeps
+ * its bytes. FB006 holds every comment interpolation to this function.
+ *
+ * The result is ONE line: a multi-line value is flattened, which is right for a `//`
+ * line or a single ` * ` body line. To keep a value's line breaks, use `commentLines`
+ * (one escaped, prefixed line per input line) or `docComment` (a whole `/** … *\/`).
+ */
+export declare function commentText(value: string | number): string;
+/**
+ * `value` split on its line terminators, each line escaped by `commentText` and
+ * given `prefix` (`'// '`, `' * '`), trailing whitespace trimmed so a blank line is
+ * a bare `//` or ` *`. The lines are joined with `\n` by the caller, so a value's
+ * paragraph breaks survive and none of them can end the comment.
+ */
+export declare function commentLines(value: string | number, prefix?: string): string[];
+/**
+ * A JSDoc comment holding `value`, at `indent`. A one-line value keeps the
+ * one-line form, `/** value *\/`, so its bytes do not change; a multi-line value
+ * gets an open block with one ` * ` line per input line.
+ */
+export declare function docComment(value: string | number, indent?: string): string[];

package/dist/core/comment-text.js

@@ -0,0 +1,40 @@
+/** The line terminators (LF, CR, CRLF, U+2028, U+2029): the one way out of a `//` comment. */
+const LINE_BREAK = /\r\n?|[\n\u2028\u2029]/g;
+/**
+ * Text that is safe inside a generated `//` or `/* … *\/` comment.
+ *
+ * A decompiler or generator that splices an input string into a comment hands that
+ * string the rest of the comment: a line terminator ends a `//` comment, `*\/` ends a
+ * block, and whatever follows is CODE in a file `compile` later executes. Those are the
+ * only two ways out of a JavaScript comment, so replacing both (line terminators — LF,
+ * CR, U+2028, U+2029 — with one space, `*\/` with `* /`) is complete, not a denylist.
+ * The replacements are the ones registry/generators already used, so their output keeps
+ * its bytes. FB006 holds every comment interpolation to this function.
+ *
+ * The result is ONE line: a multi-line value is flattened, which is right for a `//`
+ * line or a single ` * ` body line. To keep a value's line breaks, use `commentLines`
+ * (one escaped, prefixed line per input line) or `docComment` (a whole `/** … *\/`).
+ */
+export function commentText(value) {
+    return String(value).replace(LINE_BREAK, ' ').replaceAll('*/', '* /');
+}
+/**
+ * `value` split on its line terminators, each line escaped by `commentText` and
+ * given `prefix` (`'// '`, `' * '`), trailing whitespace trimmed so a blank line is
+ * a bare `//` or ` *`. The lines are joined with `\n` by the caller, so a value's
+ * paragraph breaks survive and none of them can end the comment.
+ */
+export function commentLines(value, prefix = '') {
+    return String(value).split(LINE_BREAK).map((line) => `${prefix}${commentText(line)}`.trimEnd());
+}
+/**
+ * A JSDoc comment holding `value`, at `indent`. A one-line value keeps the
+ * one-line form, `/** value *\/`, so its bytes do not change; a multi-line value
+ * gets an open block with one ` * ` line per input line.
+ */
+export function docComment(value, indent = '') {
+    const body = commentLines(value);
+    if (body.length === 1)
+        return [`${indent}/** ${commentText(value)} */`];
+    return [`${indent}/**`, ...body.map((line) => `${indent} * ${line}`.trimEnd()), `${indent} */`];
+}

package/dist/core/contribution-bindings.d.ts

@@ -0,0 +1,73 @@
+/**
+ * The `bindings[]` entries a contribution-lowered node needs and did not supply
+ * (flow-builder-sdk#942).
+ *
+ * A definition's `model.context` names its resource through `<bindings.NAME>`
+ * placeholders, and declares each NAME in `model.bindings.values`. The typed
+ * emitters (rpa, api-workflow, queue, ixp, connector) close those names by hand.
+ * A `rawNode` or a hand-written `FlowAction` returns a definition and inputs, and
+ * usually no `bindings` — so before this, nothing closed them, and compile failed
+ * at `BINDING_PLACEHOLDER_UNRESOLVED` while `check` passed.
+ *
+ * For instance, the manifest `registry get --local` returns for a sibling Flow:
+ *
+ * ```json
+ * "model": { "bindings": { "resource": "process", "resourceSubType": "Flow", "resourceKey": "k1",
+ *   "values": [{ "name": "name", "default": "Notifier" }, { "name": "folderPath", "default": "" }] },
+ *   "context": [{ "name": "name", "value": "<bindings.name>" }, { "name": "folderPath", "value": "<bindings.folderPath>" }] }
+ * ```
+ *
+ * needs two `process` entries keyed `k1`: `name` = "Notifier" and `folderPath` = "".
+ * {@link planContributionBindings} reads exactly those facts off the definition.
+ *
+ * `connection` resources are out of scope: a connector definition's entries are
+ * keyed by the tenant connection id, which the definition does not carry. A raw
+ * connector node is refused for that reason (`connector-raw-node.ts`).
+ *
+ * Pure: `serialize` lowers with it, and `check` runs it dry so the two agree.
+ */
+/** One `bindings[]` entry, as the flow file carries it. */
+export interface PlannedBinding {
+    name: string;
+    type: string;
+    resource: string;
+    resourceKey: string;
+    default?: string;
+    propertyAttribute: string;
+    resourceSubType?: string;
+}
+/** What one definition needs: the entries to build, and the names it cannot close. */
+export interface ContributionBindingPlan {
+    /** The resource kind (`model.bindings.resource`), when it is one this plan closes. */
+    resource?: string;
+    /** The resource key every entry carries (`model.bindings.resourceKey`). */
+    resourceKey?: string;
+    /** One entry per referenced name the contribution did not supply. */
+    entries: PlannedBinding[];
+    /** One sentence per referenced name that cannot be closed, and why. Empty when every name closes. */
+    problems: string[];
+}
+/** The `<bindings.NAME>` names a definition's `model.context` references, in order, once each. */
+export declare function referencedBindingNames(model: any): string[];
+/**
+ * Plan the entries a contribution-lowered node needs: for each `<bindings.NAME>`
+ * its definition's `model.context` references and `supplied` does not cover, one
+ * entry built from the definition — `resource`, `resourceKey`, `resourceSubType`
+ * from `model.bindings`, and `name`, `default`, `propertyAttribute` from the
+ * matching `model.bindings.values` row.
+ *
+ * A supplied entry covers a name when it has the same `resource` and `name`: the
+ * contributor's own bindings win, as they always did.
+ *
+ * A name is a problem (not an entry) when the definition declares no
+ * `values` row for it, or carries no `resourceKey` — a per-tenant template such
+ * as the bundled `core.action.queue.create` (`resourceKey: ""`), which only a
+ * typed factory can fill.
+ *
+ * @param def - The resolved definition.
+ * @param supplied - The bindings the contribution returned.
+ */
+export declare function planContributionBindings(def: any, supplied?: readonly {
+    resource?: string;
+    name?: string;
+}[]): ContributionBindingPlan;

package/dist/core/contribution-bindings.js

@@ -0,0 +1,105 @@
+/**
+ * The `bindings[]` entries a contribution-lowered node needs and did not supply
+ * (flow-builder-sdk#942).
+ *
+ * A definition's `model.context` names its resource through `<bindings.NAME>`
+ * placeholders, and declares each NAME in `model.bindings.values`. The typed
+ * emitters (rpa, api-workflow, queue, ixp, connector) close those names by hand.
+ * A `rawNode` or a hand-written `FlowAction` returns a definition and inputs, and
+ * usually no `bindings` — so before this, nothing closed them, and compile failed
+ * at `BINDING_PLACEHOLDER_UNRESOLVED` while `check` passed.
+ *
+ * For instance, the manifest `registry get --local` returns for a sibling Flow:
+ *
+ * ```json
+ * "model": { "bindings": { "resource": "process", "resourceSubType": "Flow", "resourceKey": "k1",
+ *   "values": [{ "name": "name", "default": "Notifier" }, { "name": "folderPath", "default": "" }] },
+ *   "context": [{ "name": "name", "value": "<bindings.name>" }, { "name": "folderPath", "value": "<bindings.folderPath>" }] }
+ * ```
+ *
+ * needs two `process` entries keyed `k1`: `name` = "Notifier" and `folderPath` = "".
+ * {@link planContributionBindings} reads exactly those facts off the definition.
+ *
+ * `connection` resources are out of scope: a connector definition's entries are
+ * keyed by the tenant connection id, which the definition does not carry. A raw
+ * connector node is refused for that reason (`connector-raw-node.ts`).
+ *
+ * Pure: `serialize` lowers with it, and `check` runs it dry so the two agree.
+ */
+/** The `<bindings.NAME>` names a definition's `model.context` references, in order, once each. */
+export function referencedBindingNames(model) {
+    const names = [];
+    for (const row of Array.isArray(model?.context) ? model.context : []) {
+        const name = typeof row?.value === 'string' ? /^<bindings\.(.+)>$/.exec(row.value)?.[1] : undefined;
+        if (name !== undefined && !names.includes(name))
+            names.push(name);
+    }
+    return names;
+}
+/**
+ * Plan the entries a contribution-lowered node needs: for each `<bindings.NAME>`
+ * its definition's `model.context` references and `supplied` does not cover, one
+ * entry built from the definition — `resource`, `resourceKey`, `resourceSubType`
+ * from `model.bindings`, and `name`, `default`, `propertyAttribute` from the
+ * matching `model.bindings.values` row.
+ *
+ * A supplied entry covers a name when it has the same `resource` and `name`: the
+ * contributor's own bindings win, as they always did.
+ *
+ * A name is a problem (not an entry) when the definition declares no
+ * `values` row for it, or carries no `resourceKey` — a per-tenant template such
+ * as the bundled `core.action.queue.create` (`resourceKey: ""`), which only a
+ * typed factory can fill.
+ *
+ * @param def - The resolved definition.
+ * @param supplied - The bindings the contribution returned.
+ */
+export function planContributionBindings(def, supplied = []) {
+    const model = def?.model;
+    const names = referencedBindingNames(model);
+    const resource = model?.bindings?.resource;
+    // Connection (or undeclared) resources are keyed by a tenant connection id the
+    // definition does not carry; the connector paths own them.
+    if (names.length === 0 || typeof resource !== 'string' || !resource || resource === 'connection') {
+        return { entries: [], problems: [] };
+    }
+    const open = names.filter((n) => !supplied.some((b) => b?.resource === resource && b?.name === n));
+    if (open.length === 0)
+        return { resource, entries: [], problems: [] };
+    const label = `${def?.nodeType}@${def?.version}`;
+    const resourceKey = model.bindings.resourceKey;
+    if (typeof resourceKey !== 'string' || !resourceKey) {
+        return {
+            resource,
+            entries: [],
+            problems: open.map((n) => `${label} references "<bindings.${n}>", and its model.bindings carries no resourceKey, so no `
+                + `"${resource}" binding can be built for it. This definition is a per-tenant template, not a resolved `
+                + `manifest: use the typed factory for the family, or the manifest \`uip maestro flow registry get `
+                + `${def?.nodeType}\` returns for a real resource, or return the bindings from contribute().`),
+        };
+    }
+    const values = Array.isArray(model.bindings.values) ? model.bindings.values : [];
+    const subType = model.bindings.resourceSubType;
+    const entries = [];
+    const problems = [];
+    for (const n of open) {
+        const row = values.find((r) => r?.name === n);
+        if (!row) {
+            problems.push(`${label} references "<bindings.${n}>", but its model.bindings.values declares no "${n}" row, so `
+                + `there is no default to bind it to. Pass the manifest exactly as \`uip maestro flow registry get\` `
+                + `returns it, or return the "${n}" binding from contribute().`);
+            continue;
+        }
+        entries.push({
+            name: n,
+            type: typeof row.type === 'string' && row.type ? row.type : 'string',
+            resource,
+            resourceKey,
+            ...(typeof row.default === 'string' ? { default: row.default } : {}),
+            propertyAttribute: typeof row.propertyAttribute === 'string' && row.propertyAttribute
+                ? row.propertyAttribute : n,
+            ...(typeof subType === 'string' && subType ? { resourceSubType: subType } : {}),
+        });
+    }
+    return { resource, resourceKey, entries, problems };
+}

package/dist/core/expr-check.js

@@ -29,7 +29,7 @@
  * and gets back diagnostics with no location. The caller stamps the location
  * (which node / task / field) it came from.
  */
-import * as ts from 'typescript';
+import { typescript } from './typescript-module.js';
 /**
  * A JSONPath wildcard/filter step — the spelling that reaches for JavaScript and
  * misses. Used only to add a suggestion; the parse decides.
@@ -47,15 +47,18 @@ const JSONPATH_WILDCARD = /\[\s*(?:\*|\?|'[^']*'|"[^"]*")\s*\]|\.\.[A-Za-z_$]/;
  * `ts.createSourceFile` is a parse, not an evaluation — nothing in `expr` runs.
  * TypeScript is already a runtime dependency of this package (see
  * `core/script-return.ts`, which infers a script's return type the same way), so
- * this adds no dependency.
+ * this adds no dependency. It is loaded on the first check, not at import
+ * (`core/typescript-module.ts`).
  */
 function syntaxError(expr) {
+    const ts = typescript();
     const problems = parseExpression(expr).problems;
     if (problems.length === 0)
         return undefined;
     return ts.flattenDiagnosticMessageText(problems[0].messageText, ' ');
 }
 function parseExpression(expr) {
+    const ts = typescript();
     const source = ts.createSourceFile('expression.ts', `(${expr}\n)`, ts.ScriptTarget.ES2020, 
     /* setParentNodes */ false);
     // `parseDiagnostics` is where the scanner records syntax problems. It is not on
@@ -77,6 +80,7 @@ function retype(expr, escapes, keepCooked) {
 }
 /** The value a leaf denotes — a name, or a literal's value (a regular expression's is its source). */
 function leafValue(node) {
+    const ts = typescript();
     if (ts.isIdentifier(node) || ts.isPrivateIdentifier(node))
         return node.text;
     // NumericLiteral … TemplateTail: every literal and template piece carries `.text`.
@@ -86,6 +90,7 @@ function leafValue(node) {
     return undefined;
 }
 function children(node) {
+    const ts = typescript();
     const out = [];
     ts.forEachChild(node, (c) => { out.push(c); });
     return out;

package/dist/core/json-file.d.ts

@@ -0,0 +1 @@
+export declare function writeJsonFile(path: string, value: unknown): void;

package/dist/core/json-file.js

@@ -0,0 +1,12 @@
+/**
+ * Write `value` as an emitted JSON artifact: 2-space indent and a trailing newline.
+ *
+ * Every emitted `.flow`, caseplan, entry-points, bindings_v2 and library file is
+ * byte-locked, and twelve call sites each spelled this out by hand; a copy that dropped
+ * the `'\n'` would break byte-lock on that one artifact only. FB007 holds pretty-printed
+ * JSON writes to this function. Creating the parent directory stays the caller's job.
+ */
+import { writeFileSync } from 'node:fs';
+export function writeJsonFile(path, value) {
+    writeFileSync(path, JSON.stringify(value, null, 2) + '\n');
+}

package/dist/core/script-return.js

@@ -28,7 +28,7 @@
  * into a designer error — the exact defect this file exists to remove, pointed
  * the other way.
  */
-import * as ts from 'typescript';
+import { typescript } from './typescript-module.js';
 /** Normalize whatever the author wrote into the emitted shape. */
 export function declaredScriptShape(returns) {
     if (typeof returns === 'string')
@@ -59,6 +59,7 @@ export function declaredScriptShape(returns) {
  * fields written down says so with `returns: {…}`.
  */
 export function inferScriptShape(code) {
+    const ts = typescript();
     // Wrap so a top-level `return` parses — this is how the runtime executes it.
     const sf = ts.createSourceFile('script.ts', `function __block() {\n${code}\n}`, ts.ScriptTarget.ES2020, true);
     // `var d = Math.floor(...); return { days: d }` is how these bodies are
@@ -99,6 +100,7 @@ export function inferScriptShape(code) {
 }
 /** The type of one expression, or undefined when it is not written down. */
 function typeOf(expr, locals, depth) {
+    const ts = typescript();
     // Bounded: a local initialized from another local is followed, a cycle is not.
     if (depth > 8)
         return undefined;
@@ -163,6 +165,7 @@ function typeOf(expr, locals, depth) {
 }
 /** `a + b`, comparisons, and the short-circuit operators. */
 function binaryShape(e, locals, depth) {
+    const ts = typescript();
     const op = e.operatorToken.kind;
     // A comparison is a boolean whatever its operands are.
     if (op === ts.SyntaxKind.EqualsEqualsToken || op === ts.SyntaxKind.EqualsEqualsEqualsToken

package/dist/core/typed-raw-node.js

@@ -55,6 +55,7 @@ export const TYPED_FACTORIES = {
     'core.logic.switch': { factory: '.switch()', bundled: ['1.0.0', '1.1'] },
     'core.logic.terminate': { factory: '.terminate()', bundled: ['1.0.0', '1.0'] },
     'core.subflow': { factory: 'subflow(child, inputs)', bundled: ['1.0.0', '1.0'] },
+    'uipath.agent.autonomous': { factory: 'inlineAgent()', bundled: ['1.2', '1.3', '1.4'] },
     'uipath.agent.conversational': { factory: 'conversationalAgent()', bundled: ['1.6', '1.7'] },
     'uipath.agent.voice': { factory: 'voiceAgent()', bundled: ['1.0', '1.1'] },
     'uipath.conversational.get-conversation-context': { factory: 'conversationContext()', bundled: ['1.0'] },

package/dist/core/typescript-module.d.ts

@@ -0,0 +1,2 @@
+import type * as TS from 'typescript';
+export declare function typescript(): typeof TS;

package/dist/core/typescript-module.js

@@ -0,0 +1,18 @@
+/// <reference types="node" />
+/**
+ * The TypeScript compiler, loaded on first use.
+ *
+ * Every builder entry reaches the expression and script checkers, and loading the compiler
+ * costs ~120 ms that a flow which never runs those checks should not pay (FB009). The
+ * specifier stays a literal at the call so the architecture lint sees the edge (as a lazy
+ * one); FB005 keeps this the only definition.
+ *
+ * The triple-slash reference: tests type-check generated code against `flow-sdk.ts`'s
+ * import graph without `@types/node` in scope, and this is the one `node:` import in that
+ * graph. Without it they fail with TS2307 on 'node:module'. It is not emitted into the .d.ts.
+ */
+import { createRequire } from 'node:module';
+let typescriptModule;
+export function typescript() {
+    return (typescriptModule ??= createRequire(import.meta.url)('typescript'));
+}