@uipath/maestro-builder-sdk 6.30.2 → 6.30.4

package/dist/bindings-v2.d.ts

@@ -97,5 +97,24 @@ export declare function inlineAgentResources(files: InlineAgentFiles): BindingsV
  * connection row's `resource` as `connection`.
  */
 export declare function mergeInlineAgentResources(existing: BindingsV2Resource[], fresh: BindingsV2Resource[]): BindingsV2Resource[];
+/**
+ * A project's resource rows with its inline agents' rows re-derived, the way
+ * compile writes them into `bindings_v2.json` (#962), and used by merge when it
+ * carries an agent's resource change (#1221).
+ *
+ * Each agent's rows come from its directory as it now stands
+ * ({@link inlineAgentResources}). The rows a REMOVED resource declared go with
+ * it: refresh never retracts a row, so an index the flow dropped would stay
+ * declared and a deploy could still fail on it. They are generated by the same
+ * function, so they match exactly, and a row a remaining resource still
+ * declares is kept. Connection rows are not touched here: compile re-derives
+ * them from the flow ({@link connectionResources}).
+ *
+ * @param resources - The project's current rows.
+ * @param agents - Every inline agent's files, as they now stand.
+ * @param removedResources - The `resource.json` bodies of the resources removed.
+ * @returns The rows to write.
+ */
+export declare function refreshInlineAgentRows(resources: BindingsV2Resource[], agents: InlineAgentFiles[], removedResources: unknown[]): BindingsV2Resource[];
 /** Read one inline agent's directory the way refresh does; `undefined` when it has no readable `agent.json`. */
 export declare function readInlineAgentFiles(agentDir: string): InlineAgentFiles | undefined;

package/dist/bindings-v2.js

@@ -507,6 +507,35 @@ export function mergeInlineAgentResources(existing, fresh) {
     }
     return out;
 }
+/**
+ * A project's resource rows with its inline agents' rows re-derived, the way
+ * compile writes them into `bindings_v2.json` (#962), and used by merge when it
+ * carries an agent's resource change (#1221).
+ *
+ * Each agent's rows come from its directory as it now stands
+ * ({@link inlineAgentResources}). The rows a REMOVED resource declared go with
+ * it: refresh never retracts a row, so an index the flow dropped would stay
+ * declared and a deploy could still fail on it. They are generated by the same
+ * function, so they match exactly, and a row a remaining resource still
+ * declares is kept. Connection rows are not touched here: compile re-derives
+ * them from the flow ({@link connectionResources}).
+ *
+ * @param resources - The project's current rows.
+ * @param agents - Every inline agent's files, as they now stand.
+ * @param removedResources - The `resource.json` bodies of the resources removed.
+ * @returns The rows to write.
+ */
+export function refreshInlineAgentRows(resources, agents, removedResources) {
+    const agentRows = agents.map((files) => inlineAgentResources(files));
+    const live = new Set(agentRows.flat().map((r) => `${r.resource}\u0000${r.key}`));
+    const stale = new Set(inlineAgentResources({ agent: {}, resources: removedResources, features: [] })
+        .filter((r) => r.resource !== 'connection' && !live.has(`${r.resource}\u0000${r.key}`))
+        .map((r) => `${r.resource}\u0000${r.key}`));
+    let out = resources.filter((r) => !stale.has(`${r.resource}\u0000${r.key}`));
+    for (const rows of agentRows)
+        out = mergeInlineAgentResources(out, rows);
+    return out;
+}
 /** Read one inline agent's directory the way refresh does; `undefined` when it has no readable `agent.json`. */
 export function readInlineAgentFiles(agentDir) {
     let agent;

package/dist/compile-cli.js

@@ -27,10 +27,11 @@ import { check } from './check.js';
 import { flowCheckOpts, openCliLibrary } from './cli-library.js';
 import { Bindings } from './bindings.js';
 import { flagValue, runWhenInvokedDirectly } from './cli-run.js';
-import { connectionResources, inlineAgentResources, mergeBindingsV2, mergeInlineAgentResources, readBindingsV2, readInlineAgentFiles, } from './bindings-v2.js';
+import { connectionResources, inlineAgentResources, mergeBindingsV2, readBindingsV2, refreshInlineAgentRows, readInlineAgentFiles, } from './bindings-v2.js';
 import { ensureTypeScriptRuntime } from './node-runtime.js';
 import { defaultBindingsFile } from './workdir.js';
 import { isWithin } from './path-within.js';
+import { resourceSourcesOfOtherFlows } from './project-resource-users.js';
 import { BindingRefusal } from './core/binding-messages.js';
 import { ByoaRefusal } from './core/byoa.js';
 export async function run(argv) {
@@ -225,26 +226,15 @@ export async function run(argv) {
         // requires every one of them, so leaving them to a refresh the SDK route
         // never runs made every agent with a deployed-resource tool, a context index
         // or an app escalation fail validate with `AgentValidationDrift`.
-        const agentRows = agentDirs
+        const agentFiles = agentDirs
             .map((dir) => readInlineAgentFiles(dir))
-            .filter((files) => files !== undefined)
-            .map((files) => inlineAgentResources(files));
-        // The rows a PRUNED resource declared go with it: refresh never retracts a
-        // row, so an index the flow dropped would stay declared and a deploy could
-        // still fail on it. Generated by the same function, so they match exactly,
-        // and kept when a resource that still exists declares the same row.
-        // Connection rows are skipped: every one is re-derived from the flow below.
-        const live = new Set(agentRows.flat().map((r) => `${r.resource}\u0000${r.key}`));
-        const stale = new Set(inlineAgentResources({ agent: {}, resources: removedResources, features: [] })
-            .filter((r) => r.resource !== 'connection' && !live.has(`${r.resource}\u0000${r.key}`))
-            .map((r) => `${r.resource}\u0000${r.key}`));
+            .filter((files) => files !== undefined);
+        const agentRows = agentFiles.map((files) => inlineAgentResources(files));
         // Nothing to declare and nothing already declared — do not create an empty
         // file for a flow that has no resources at all.
         if (connections.length > 0 || existing !== undefined || agentRows.some((rows) => rows.length > 0)) {
             const merged = mergeBindingsV2(existing, connections);
-            merged.resources = merged.resources.filter((r) => !stale.has(`${r.resource}\u0000${r.key}`));
-            for (const rows of agentRows)
-                merged.resources = mergeInlineAgentResources(merged.resources, rows);
+            merged.resources = refreshInlineAgentRows(merged.resources, agentFiles, removedResources);
             writeJsonFile(sidecarPath, merged);
             const derived = new Set([...connections, ...agentRows.flat()].map((r) => `${r.resource}\u0000${r.key}`));
             const agentCount = merged.resources.filter((r) => r.resource !== 'connection' && derived.has(`${r.resource}\u0000${r.key}`)).length;
@@ -260,42 +250,3 @@ function serializeWarningDiagnostic(w) {
     return { level: 'warning', code: w.code, message: w.message };
 }
 runWhenInvokedDirectly(import.meta.url, 'compile', run);
-/**
- * The `inputs.source` uuids the OTHER `.flow` files in `dir` reference, each
- * mapped to the first file that does. `dir` is the namespace sidecar paths are
- * relative to, so these are the agent resources another flow still uses. The
- * flow being written (`self`) is left out: what it no longer references is what
- * pruning is for. Subflow bodies are included; an unreadable file contributes
- * nothing.
- */
-function resourceSourcesOfOtherFlows(dir, self) {
-    const users = new Map();
-    let entries;
-    try {
-        entries = readdirSync(dir).filter((f) => f.endsWith('.flow') && resolve(dir, f) !== self);
-    }
-    catch {
-        return users;
-    }
-    for (const f of entries) {
-        let flow;
-        try {
-            flow = JSON.parse(readFileSync(join(dir, f), 'utf8'));
-        }
-        catch {
-            continue;
-        }
-        const walk = (scope) => {
-            const s = scope;
-            for (const n of Array.isArray(s?.nodes) ? s.nodes : []) {
-                const src = n?.inputs?.source;
-                if (typeof src === 'string' && !users.has(src))
-                    users.set(src, f);
-            }
-            if (s?.subflows && typeof s.subflows === 'object')
-                Object.values(s.subflows).forEach(walk);
-        };
-        walk(flow);
-    }
-    return users;
-}

package/dist/core/context-index.d.ts

@@ -32,3 +32,21 @@ export declare function parseContextIndexType(type: string): {
     slug: string;
     id: string;
 } | undefined;
+/**
+ * The retrieval settings an index gets when the author sets none: what
+ * `contextResourceJson` (serialize.ts) writes into `resource.json` `settings`, and
+ * what decompile leaves out of the source because compile would write it anyway.
+ */
+export declare const CONTEXT_INDEX_DEFAULTS: {
+    readonly retrievalMode: "semantic";
+    readonly threshold: 0;
+    readonly resultCount: 3;
+};
+/**
+ * The file extension each retrieval mode accepts by default. The platform's
+ * manifest defaults every mode's NODE to `All`, but its resource schema pins
+ * `structured`/`batchtransform` to `csv` and `deeprag` to `pdf`/`txt` — so a
+ * flat `All` default would emit a resource the platform refuses to parse for
+ * every mode but `semantic`.
+ */
+export declare const CONTEXT_INDEX_DEFAULT_FILE_EXTENSION: Readonly<Record<string, string>>;

package/dist/core/context-index.js

@@ -36,3 +36,22 @@ export function parseContextIndexType(type) {
     const dot = tail.lastIndexOf('.');
     return dot < 0 ? { slug: tail, id: '' } : { slug: tail.slice(0, dot), id: tail.slice(dot + 1) };
 }
+/**
+ * The retrieval settings an index gets when the author sets none: what
+ * `contextResourceJson` (serialize.ts) writes into `resource.json` `settings`, and
+ * what decompile leaves out of the source because compile would write it anyway.
+ */
+export const CONTEXT_INDEX_DEFAULTS = { retrievalMode: 'semantic', threshold: 0, resultCount: 3 };
+/**
+ * The file extension each retrieval mode accepts by default. The platform's
+ * manifest defaults every mode's NODE to `All`, but its resource schema pins
+ * `structured`/`batchtransform` to `csv` and `deeprag` to `pdf`/`txt` — so a
+ * flat `All` default would emit a resource the platform refuses to parse for
+ * every mode but `semantic`.
+ */
+export const CONTEXT_INDEX_DEFAULT_FILE_EXTENSION = {
+    semantic: 'All',
+    structured: 'csv',
+    deeprag: 'pdf',
+    batchtransform: 'csv',
+};

package/dist/decompile-cli.js

@@ -150,7 +150,8 @@ if (!existsSync(BASELINE)) {
   if (existsSync(BASELINE)) args.push('--baseline', BASELINE);
   run('merge', args);
   console.log('\\n>>> Wrote ' + ${JSON.stringify(base + '.merged.flow')}
-    + '. Replace the original with it, together with every <source>/ file merge reports writing beside it.');
+    + '. Replace the original with it, together with every <source>/ file merge reports writing beside it,'
+    + ' and delete every directory merge lists under "remove".');
 }
 `;
 }

package/dist/decompile.d.ts

@@ -144,9 +144,11 @@ export interface DecompileOptions {
      * (`{{input.start__output__notes}}`), so the recovered source declares its
      * inputs under those names — the same flow, not the same spelling. Without a
      * reader, a shell agent decompiles with empty prompts and a warning.
-     * A context index placed by the canvas or the CLI keeps its real name and
-     * folder only in `<agent source>/resources/<inputs.source>/resource.json`,
-     * which is read the same way.
+     * A context index placed by the canvas or the CLI keeps its real name,
+     * folder and retrieval `settings` (mode, query, threshold, result count, file
+     * extension) only in `<agent source>/resources/<inputs.source>/resource.json`,
+     * which is read the same way. A setting `context: [...]` cannot express is
+     * reported through `warn` (an error when `bestEffort` is false).
      */
     readSidecar?: (relativePath: string) => string | undefined;
 }

package/dist/decompile.js

@@ -36,7 +36,8 @@ import { FLOW_NODE_TYPES } from './flow-node-registry.js';
 import { SUBFLOW_START_LABEL } from './core/subflow-start.js';
 import { commentText } from './core/comment-text.js';
 import { tsLiteral, tsNumber, tsText } from './core/ts-literal.js';
-import { contextIndexSlug, parseContextIndexType } from './core/context-index.js';
+import { ownEntry } from './core/own-entry.js';
+import { CONTEXT_INDEX_DEFAULTS, CONTEXT_INDEX_DEFAULT_FILE_EXTENSION, contextIndexSlug, parseContextIndexType, } from './core/context-index.js';
 import { wireExprBody } from './core/wire-expr.js';
 import { hasExits } from './core/step-ports.js';
 import { parseIxpProjectType } from './core/actions.js';
@@ -914,7 +915,146 @@ function contextIndexIdentity(agent, c, rPlain) {
             + `will write a different node type. Set \`name\` to the index's real name`
             + (sidecar === undefined ? ', or keep the resources/ folder beside the .flow so decompile can read it.' : '.'));
     }
-    return { name, id, folderPath: rPlain(c, 'folderPath') ?? sidecarText('folderPath') };
+    return { name, id, folderPath: rPlain(c, 'folderPath') ?? sidecarText('folderPath'), sidecar };
+}
+/** The retrieval modes `ContextIndexRef.retrievalMode` can hold. */
+const CONTEXT_RETRIEVAL_MODES = new Set(['semantic', 'structured', 'deeprag', 'batchtransform']);
+/** The `settings` keys of a context `resource.json` that {@link contextIndexSettings} reads or checks. */
+const CONTEXT_SETTINGS_KEYS = new Set([
+    'retrievalMode', 'query', 'folderPathPrefix', 'threshold', 'resultCount', 'fileExtension',
+    'citationMode', 'webSearchGrounding', 'outputColumns',
+]);
+/**
+ * A context index's retrieval settings, as the `context: [...]` entry's option
+ * rows (`retrievalMode`, `query`, `threshold`, `resultCount`, `fileExtension`),
+ * each left out when it is what compile writes anyway.
+ *
+ * The inverse of `contextResourceJson` (serialize.ts). Read from the sidecar's
+ * `settings` first: a node the canvas or the CLI placed keeps its inputs minimal
+ * (`inputs.source`), so `resource.json` is the only copy, and it is what the
+ * runtime reads. The node's own inputs (the SDK writes both) answer when there
+ * is no sidecar. Before #1183 neither was read, so a no-edit round trip reset
+ * every setting to the SDK default without a word.
+ *
+ * The query is variant-tagged in the sidecar and mode-tagged on the node:
+ *
+ *  - `dynamic` / `prompt` → a plain string (the guidance the model reads);
+ *  - `static` / `text-builder` whose text is a `=js:` expression → that
+ *    expression, which compile writes back as `text-builder` / `static`;
+ *  - `static` with `''` is the canvas's spelling of "no query", as the SDK's
+ *    `dynamic` with `''` is: left out.
+ *
+ * A setting the SDK cannot express (a `static` query of plain text, an
+ * `argument` query, deeprag citations off, batchtransform web grounding off or
+ * output columns, a folder-path prefix, an unknown mode or key) is reported:
+ * a warning, or an error under `--strict`. Compile would write the SDK's
+ * value instead, so it is never dropped silently.
+ */
+function contextIndexSettings(agent, c, sidecar) {
+    const settings = sidecar?.settings && typeof sidecar.settings === 'object' && !Array.isArray(sidecar.settings)
+        ? sidecar.settings : undefined;
+    const ni = (c.inputs ?? {});
+    const where = `context index "${c.id}" on agent "${agent.id}"`;
+    const lossy = (what) => {
+        const message = `${where}: ${what}, which \`context: [...]\` cannot express, so compile writes the SDK's `
+            + `value instead. Edit that setting in the canvas after merging, or keep the original resource.json.`;
+        if (runStrict)
+            throw new Error(`decompile: ${message}`);
+        warnOnce(message);
+    };
+    const textOf = (v) => (typeof v === 'string' ? v : undefined);
+    const numOf = (v) => {
+        const raw = unwrapPlain(v);
+        return typeof raw === 'number' && Number.isFinite(raw) ? raw : undefined;
+    };
+    const valueOf = (v) => (v && typeof v === 'object' ? v.value : undefined);
+    // Retrieval mode.
+    const rawMode = textOf(settings?.retrievalMode) ?? textOf(unwrapSource(ni.retrievalMode));
+    let mode = CONTEXT_INDEX_DEFAULTS.retrievalMode;
+    if (rawMode !== undefined && rawMode !== '') {
+        if (CONTEXT_RETRIEVAL_MODES.has(rawMode))
+            mode = rawMode;
+        else
+            lossy(`its retrieval mode is ${JSON.stringify(rawMode)}`);
+    }
+    const sidecarQuery = (() => {
+        const q = settings?.query;
+        if (!q || typeof q !== 'object')
+            return undefined;
+        if (q.variant === 'dynamic')
+            return { kind: 'prompt', text: textOf(q.description) ?? '' };
+        if (q.variant === 'static')
+            return { kind: 'text', text: textOf(q.value) ?? '' };
+        if (q.variant === 'argument')
+            return { kind: 'argument', text: textOf(q.value) ?? '' };
+        lossy(`its query has variant ${JSON.stringify(q.variant)}`);
+        return undefined;
+    })();
+    const nodeQuery = (() => {
+        const q = ni.query;
+        if (typeof q === 'string')
+            return q === '' ? undefined : { kind: q.startsWith('=js:') ? 'text' : 'prompt', text: q };
+        if (!q || typeof q !== 'object')
+            return undefined;
+        const t = q;
+        if (t.mode === 'text-builder')
+            return { kind: 'text', text: textOf(t.textValue) ?? '' };
+        if (t.mode === 'variable')
+            return { kind: 'argument', text: textOf(t.argumentPath) ?? '' };
+        return { kind: 'prompt', text: textOf(t.promptValue) ?? '' };
+    })();
+    const query = sidecarQuery ?? nodeQuery;
+    let querySrc;
+    if (query?.kind === 'prompt' && query.text !== '')
+        querySrc = tsLiteral(query.text);
+    else if (query?.kind === 'text' && query.text.startsWith('=js:'))
+        querySrc = tsLiteral(query.text);
+    else if (query?.kind === 'text' && query.text !== '')
+        lossy(`its query is static text (${JSON.stringify(query.text)})`);
+    else if (query?.kind === 'argument')
+        lossy(`its query is the agent argument ${JSON.stringify(query.text)}`);
+    // Numbers and the file extension.
+    const threshold = numOf(settings?.threshold) ?? numOf(ni.threshold);
+    const resultCount = numOf(settings?.resultCount) ?? numOf(ni.resultCount);
+    const fileExtension = textOf(valueOf(settings?.fileExtension)) ?? textOf(unwrapSource(ni.fileExtension));
+    // The node's flat `All` is the platform's node default for every mode; only
+    // the resource's per-mode default is what compile would write anyway.
+    const defaultExtension = ownEntry(CONTEXT_INDEX_DEFAULT_FILE_EXTENSION, mode) ?? 'All';
+    const extensionSrc = fileExtension === undefined || fileExtension === '' || fileExtension === defaultExtension
+        || (settings?.fileExtension === undefined && fileExtension === 'All')
+        ? undefined : tsLiteral(fileExtension);
+    // What compile writes as constants; anything else has no field.
+    if (mode === 'deeprag') {
+        const citation = textOf(valueOf(settings?.citationMode)) ?? textOf(unwrapSource(ni.citations));
+        if (citation !== undefined && !['Inline', 'enabled'].includes(citation))
+            lossy(`its citation mode is ${JSON.stringify(citation)}`);
+    }
+    if (mode === 'batchtransform') {
+        const grounding = textOf(valueOf(settings?.webSearchGrounding)) ?? textOf(valueOf(ni.webSearchGrounding));
+        if (grounding !== undefined && !['Enabled', 'enabled'].includes(grounding))
+            lossy(`its web search grounding is ${JSON.stringify(grounding)}`);
+        const columns = settings?.outputColumns ?? ni.outputColumns;
+        if (Array.isArray(columns) && columns.length > 0)
+            lossy(`it has ${columns.length} output column(s)`);
+    }
+    // The folder-path prefix: variant-tagged in the sidecar, mode-tagged on the node.
+    const field = (v, k) => (v && typeof v === 'object' ? textOf(v[k]) : undefined);
+    const prefixText = settings?.folderPathPrefix !== undefined
+        ? field(settings.folderPathPrefix, 'value') ?? field(settings.folderPathPrefix, 'description') ?? ''
+        : field(ni.folderPathPrefix, 'textValue') ?? field(ni.folderPathPrefix, 'promptValue') ?? '';
+    if (prefixText !== '')
+        lossy(`its folder-path prefix is ${JSON.stringify(prefixText)}`);
+    for (const k of Object.keys(settings ?? {})) {
+        if (!CONTEXT_SETTINGS_KEYS.has(k))
+            lossy(`its resource.json settings carry ${JSON.stringify(k)}`);
+    }
+    return [
+        ['query', querySrc],
+        ['retrievalMode', mode !== CONTEXT_INDEX_DEFAULTS.retrievalMode ? tsLiteral(mode) : undefined],
+        ['threshold', threshold !== undefined && threshold !== CONTEXT_INDEX_DEFAULTS.threshold ? tsNumber(threshold) : undefined],
+        ['resultCount', resultCount !== undefined && resultCount !== CONTEXT_INDEX_DEFAULTS.resultCount ? tsNumber(resultCount) : undefined],
+        ['fileExtension', extensionSrc],
+    ];
 }
 /**
  * A context resource's `resource.json` sidecar, parsed; `undefined` when it is
@@ -1136,21 +1276,14 @@ function emitAgentCluster(node, imp, inputNames, graph) {
         return opts([['kind', tsLiteral('builtin')], ['tool', tsLiteral('summarize')]]); // unreachable in practice
     });
     const contextSrc = resource('context').map((c) => {
-        // `query` is a MODE TRIPLE, not a string: the author's value lands in
-        // `promptValue` (prompt mode) or `textValue` (text-builder). Reading the
-        // field itself finds an object and silently recovers nothing.
-        const q = rInputs(c).query;
-        const queryText = typeof q?.promptValue === 'string' && q.promptValue !== '' ? q.promptValue
-            : typeof q?.textValue === 'string' && q.textValue !== '' ? q.textValue
-                : typeof q === 'string' && q !== '' ? q
-                    : undefined;
-        const { name, id, folderPath } = contextIndexIdentity(node, c, rPlain);
+        const { name, id, folderPath, sidecar } = contextIndexIdentity(node, c, rPlain);
         return opts([
             ['name', tsLiteral(name)],
             ['id', tsLiteral(id)],
             ['folderPath', folderPath !== undefined ? tsLiteral(folderPath) : undefined],
             ['folderKey', rPlain(c, 'folderKey') !== undefined ? tsLiteral(rPlain(c, 'folderKey')) : undefined],
-            ['query', queryText !== undefined ? tsLiteral(queryText) : undefined],
+            // `query` and the retrieval settings, from resource.json or the node (#1183).
+            ...contextIndexSettings(node, c, sidecar),
         ]);
     });
     const escalationSrc = resource('escalation').map((e) => {

package/dist/merge-cli.js

@@ -30,14 +30,24 @@
  * compiled the side itself (`--baseline-from`, an edited `.flow.ts`), which keeps
  * the sidecars in memory; what merge cannot carry is warned, and refused under
  * `--strict`. See merge-sidecars.ts.
+ *
+ * Agent resources (#1221): a context or tool the edit adds or changes is written
+ * beside the merged output too. One the edit REMOVES is listed, one
+ * `flow-merge: remove <dir>` line each (and `removed` in `--json`), because
+ * copying the candidate over the project cannot delete a file: delete those
+ * directories from the project. When the original sits in a Flow project
+ * (`project.uiproj`), the project's `bindings_v2.json` is re-derived for the
+ * changed agents, as compile does, and written beside the merged output.
  */
 import { reportResult } from './cli-result.js';
 import { writeJsonFile } from './core/json-file.js';
 import { existsSync, mkdirSync, readdirSync, readFileSync } from 'node:fs';
+import { readBindingsV2, readInlineAgentFiles, refreshInlineAgentRows } from './bindings-v2.js';
 import { basename, dirname, join, resolve } from 'node:path';
 import { MergeRefusedError, mergeFlowWithSidecars } from './merge.js';
 import { sidecarSetFromList } from './merge-sidecars.js';
 import { isWithin } from './path-within.js';
+import { resourceSourcesOfOtherFlows } from './project-resource-users.js';
 import { flagValue, runWhenInvokedDirectly } from './cli-run.js';
 import { ensureTypeScriptRuntime } from './node-runtime.js';
 import { flowCheckOpts, openCliLibrary } from './cli-library.js';
@@ -78,6 +88,71 @@ export function sidecarsBeside(flowPath) {
         return files;
     };
 }
+/**
+ * The project's `bindings_v2.json` after merge's resource changes, or `undefined`
+ * when the original is not in a Flow project (`project.uiproj`), no agent
+ * resource changed, the file already holds the resulting rows, or the change
+ * declares no different row (the rows derived
+ * after the change equal those derived from the project as it is, so a changed
+ * `resultCount` does not create or rewrite the file).
+ *
+ * Only the agents whose resources changed are re-derived, each from its
+ * directory as it will stand once the candidate is installed: the original's
+ * files, with merge's writes over them and its removals taken out.
+ */
+function projectBindings(projectDir, writes, removals) {
+    if (!existsSync(join(projectDir, 'project.uiproj')))
+        return undefined;
+    const isResource = (path) => /\/resources\/[^/]+\/resource\.json$/.test(path);
+    const agentOf = (path) => path.split('/')[0];
+    const changedAgents = new Set([
+        ...writes.filter((w) => isResource(w.path)).map((w) => agentOf(w.path)),
+        ...removals.map(agentOf),
+    ]);
+    if (changedAgents.size === 0)
+        return undefined;
+    const removedBodies = [];
+    const agents = [];
+    const agentsBefore = [];
+    const asResources = (files) => [...files.values()].filter((r) => !!r && typeof r === 'object' && '$resourceType' in r);
+    for (const source of changedAgents) {
+        const onDisk = readInlineAgentFiles(join(projectDir, source));
+        const files = new Map();
+        const resourcesDir = join(projectDir, source, 'resources');
+        if (existsSync(resourcesDir)) {
+            for (const entry of readdirSync(resourcesDir).sort()) {
+                try {
+                    files.set(`${source}/resources/${entry}/resource.json`, JSON.parse(readFileSync(join(resourcesDir, entry, 'resource.json'), 'utf8')));
+                }
+                catch {
+                    // Refresh skips an unreadable file the same way.
+                }
+            }
+        }
+        agentsBefore.push({ agent: onDisk?.agent ?? {}, resources: asResources(files), features: onDisk?.features ?? [] });
+        for (const dir of removals.filter((r) => agentOf(r) === source)) {
+            const path = `${dir}/resource.json`;
+            if (files.has(path))
+                removedBodies.push(files.get(path));
+            files.delete(path);
+        }
+        let agent = onDisk?.agent ?? {};
+        for (const w of writes.filter((x) => agentOf(x.path) === source)) {
+            if (w.path === `${source}/agent.json`)
+                agent = w.json;
+            else if (isResource(w.path))
+                files.set(w.path, w.json);
+        }
+        agents.push({ agent, resources: asResources(files), features: onDisk?.features ?? [] });
+    }
+    const existing = readBindingsV2(join(projectDir, 'bindings_v2.json'));
+    const before = refreshInlineAgentRows(existing?.resources ?? [], agentsBefore, []);
+    const after = refreshInlineAgentRows(existing?.resources ?? [], agents, removedBodies);
+    // Nothing to write when the change declares nothing new, or the file already says it.
+    if (JSON.stringify(after) === JSON.stringify(before) || JSON.stringify(after) === JSON.stringify(existing?.resources ?? []))
+        return undefined;
+    return { version: '2.0', ...existing, resources: after };
+}
 export async function run(argv) {
     if (argv.length === 0 || argv[0] === '-h' || argv[0] === '--help') {
         console.error(USAGE);
@@ -205,11 +280,33 @@ export async function run(argv) {
         writeJsonFile(target, sidecar.json);
         console.log(`flow-merge: wrote ${sidecar.path} (carries ${sidecar.carried.join(', ')})`);
     }
+    const originalDir = dirOf(originalPath);
+    // A resource another `.flow` in the project still names stays (compile's prune
+    // has the same guard): a decompiled canvas agent keeps its `source` directory,
+    // so two flows can share it.
+    const users = resourceSourcesOfOtherFlows(originalDir, resolve(originalPath));
+    const removals = merged.removals.filter((rel) => {
+        const user = users.get(basename(rel));
+        if (user !== undefined)
+            console.log(`flow-merge: kept ${rel}: ${user} still references it`);
+        return user === undefined;
+    });
+    const removed = removals.map((rel) => join(originalDir, rel));
+    for (const dir of removed) {
+        console.log(`flow-merge: remove ${dir} from the project: the edit removed this agent resource, and copying the candidate cannot delete it`);
+    }
+    const bindingsV2 = projectBindings(originalDir, merged.sidecars, removals);
+    if (bindingsV2 !== undefined) {
+        writeJsonFile(join(outDir, 'bindings_v2.json'), bindingsV2);
+        console.log('flow-merge: wrote bindings_v2.json (the changed agents\' resource rows, re-derived as compile does)');
+    }
     reportResult({
         path: resolve(out),
         nodes: (flow.nodes ?? []).length,
         edges: (flow.edges ?? []).length,
         ...(targets.length > 0 ? { sidecars: targets.map((t) => t.target) } : {}),
+        ...(removed.length > 0 ? { removed } : {}),
+        ...(bindingsV2 !== undefined ? { bindings: join(resolve(outDir), 'bindings_v2.json') } : {}),
     });
     return 0;
 }

package/dist/merge-sidecars.d.ts

@@ -19,6 +19,16 @@ export interface MergeSidecarSources {
     /** Why {@link baseline} is absent, phrased to finish "merge cannot tell an edit from the round trip: …". */
     baselineMissing?: string;
 }
+/** The three flows, for matching resource directories by the node that names them. */
+export interface MergeSidecarFlows {
+    original: FlowLike;
+    baseline?: FlowLike;
+    edited: FlowLike;
+}
+type FlowLike = {
+    nodes?: AnyNode[];
+    subflows?: Record<string, unknown>;
+} | undefined;
 /** One file the merged flow needs written beside it, relative to it. */
 export interface SidecarWrite {
     path: string;
@@ -64,8 +74,9 @@ export declare function mergeJson3(original: unknown, baseline: unknown, edited:
 export declare function mergeAgentSidecars(merged: {
     nodes?: AnyNode[];
     subflows?: Record<string, unknown>;
-}, sources: MergeSidecarSources): {
+}, sources: MergeSidecarSources, flows?: MergeSidecarFlows): {
     writes: SidecarWrite[];
+    removals: string[];
     findings: MergeFinding[];
 };
 export {};

package/dist/merge-sidecars.js

@@ -30,7 +30,7 @@
  * - no baseline sidecar to compare with (no `--baseline`, or the baseline and the
  *   edited compile were written to one directory, so the second overwrote the
  *   first's `<source>/`), and the edited `agent.json` differs from the original's;
- * - a change to the agent's resource files (a context or tool added or removed);
+ * - without a baseline sidecar, a change to the agent's resource files;
  * - an `agent.json` edit on a node that carries its own prompts (an embedded
  *   node: decompile, like Studio Web, reads the node's prompts first, so the
  *   edited file would not be what runs).
@@ -38,6 +38,30 @@
  * An agent the merged flow adds (no sidecar in the original) gets the edited
  * compile's files whole.
  *
+ * ## Resources (#1221)
+ *
+ * A context or tool the author adds, removes or changes is carried too. The
+ * three sides name the same resource's directory differently: the canvas by its
+ * own id (`resources/d84e2c17-…/`), compile by a uuid derived from the step and
+ * the resource (`resources/e3ed6f35-…/`). So resources are matched by IDENTITY,
+ * not directory: the id of the flow node whose `inputs.source` names the
+ * directory (node ids survive the round trip by construction), or, for a
+ * resource no node names, its content without `id`. Then, per resource:
+ *
+ *   - added (in the edited compile, not the baseline): the edited file, written
+ *     under the directory the merged node names;
+ *   - changed: the author's delta applied onto the ORIGINAL file, written back
+ *     under the original directory (the merged node keeps the original `source`,
+ *     see `mergeFlow`);
+ *   - removed (in the baseline, not the edited compile): the original directory
+ *     goes into `removals`. Copying the candidate over the project never deletes
+ *     a file, so the caller has to delete these.
+ *
+ * A resource only the original has (one compile does not emit) is left alone.
+ * A changed or removed resource that pairs with no original one (the canvas
+ * named its node, and its file has fields compile does not write) is reported,
+ * and refused under `strict`: guessing would delete or duplicate the wrong one.
+ *
  * Pure: the caller reads the files ({@link SidecarSet}) and writes the result.
  */
 import { jsonClone } from './core/json-file.js';
@@ -140,6 +164,100 @@ function resourceChanges(from, to) {
     ];
     return out.length > 0 ? out.join('; ') : undefined;
 }
+/** `<source>/resources/<dir>/resource.json` -> `<dir>`; `undefined` for any other path. */
+function resourceDir(source, path) {
+    const prefix = `${source}/resources/`;
+    if (!path.startsWith(prefix) || !path.endsWith('/resource.json'))
+        return undefined;
+    const dir = path.slice(prefix.length, -'/resource.json'.length);
+    return /^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(dir) ? dir : undefined;
+}
+/** Every node of a flow, root and subflows, by the `inputs.source` it names. */
+function nodeIdsBySource(flow) {
+    const out = new Map();
+    const walk = (scope) => {
+        const sc = scope;
+        for (const n of Array.isArray(sc?.nodes) ? sc.nodes : []) {
+            const src = n?.inputs?.source;
+            if (typeof src === 'string' && !out.has(src))
+                out.set(src, n.id);
+        }
+        if (sc?.subflows && typeof sc.subflows === 'object')
+            Object.values(sc.subflows).forEach(walk);
+    };
+    walk(flow);
+    return out;
+}
+/** A resource file without the `id` its writer derives from the directory. */
+function withoutId(json) {
+    if (!isObject(json))
+        return json;
+    const { id: _id, ...rest } = json;
+    return rest;
+}
+/**
+ * One side's resources of the agent at `source`, keyed by identity: `node:<id>`
+ * for a resource directory a node of that side's flow names in `inputs.source`,
+ * else `content:<the file without id>`.
+ */
+function resourcesByIdentity(source, files, flow) {
+    const byDir = nodeIdsBySource(flow);
+    const out = new Map();
+    for (const [path, json] of Object.entries(files)) {
+        const dir = resourceDir(source, path);
+        if (dir === undefined)
+            continue;
+        const nodeId = byDir.get(dir);
+        out.set(nodeId !== undefined ? `node:${nodeId}` : `content:${stable(withoutId(json))}`, { dir, json });
+    }
+    return out;
+}
+/**
+ * The resource files of the agent at `source` the merged flow needs, and the
+ * original resource directories it no longer has (see the module comment).
+ */
+function carryResources(source, files, flows) {
+    const o = resourcesByIdentity(source, files.original, flows.original);
+    const b = resourcesByIdentity(source, files.baseline, flows.baseline);
+    const e = resourcesByIdentity(source, files.edited, flows.edited);
+    const writes = [];
+    const removals = [];
+    /** Baseline resources the edit changed or removed that pair with no original resource. */
+    const unmatched = [];
+    const pathOf = (dir) => `${source}/resources/${dir}/resource.json`;
+    for (const key of new Set([...b.keys(), ...e.keys()])) {
+        const [ok, bk, ek] = [o.get(key), b.get(key), e.get(key)];
+        if (ek !== undefined && bk === undefined) {
+            // Added by the author. Its directory is the one the edited (and so the
+            // merged) node names; an original resource of the same identity the round
+            // trip dropped is updated in place instead.
+            if (ok !== undefined)
+                continue;
+            writes.push({ path: pathOf(ek.dir), json: jsonClone(ek.json), carried: ['added resource'] });
+        }
+        else if (ek === undefined && bk !== undefined) {
+            if (ok !== undefined)
+                removals.push(`${source}/resources/${ok.dir}`);
+            else
+                unmatched.push(pathOf(bk.dir));
+        }
+        else if (ek !== undefined && bk !== undefined && stable(withoutId(bk.json)) !== stable(withoutId(ek.json))) {
+            const changed = [];
+            if (ok === undefined) {
+                // Writing the edited file would add a second resource beside the
+                // original one it was meant to change.
+                unmatched.push(pathOf(bk.dir));
+                continue;
+            }
+            // The derived `id` is not the author's: give both compiles the original's,
+            // so only the content delta lands (and the original's key order stays).
+            const withOrigId = (json) => (isObject(json) && isObject(ok.json) && 'id' in ok.json ? { ...json, id: ok.json.id } : json);
+            const json = mergeJson3(ok.json, withOrigId(bk.json), withOrigId(ek.json), changed);
+            writes.push({ path: pathOf(ok.dir), json, carried: changed });
+        }
+    }
+    return { writes, removals, unmatched };
+}
 /** Whether a node carries its prompts itself, so its `agent.json` is not what runs (see decompile's `sidecarAgentInputs`). */
 function carriesOwnPrompts(node) {
     const i = node?.inputs ?? {};
@@ -151,8 +269,9 @@ const finding = (message) => ({ kind: 'agent-sidecar', message, refuses: true })
  * not carry. `merged` is `mergeFlow`'s result. An agent is new when the
  * original side has no `<source>/agent.json` for it.
  */
-export function mergeAgentSidecars(merged, sources) {
+export function mergeAgentSidecars(merged, sources, flows) {
     const writes = [];
+    const removals = [];
     const findings = [];
     for (const [source, node] of agentSources(merged)) {
         const edited = sources.edited(source);
@@ -202,13 +321,24 @@ export function mergeAgentSidecars(merged, sources) {
                 writes.push({ path: agentPath, json: next, carried: changed });
             }
         }
-        // Resources: report a changed set; the canvas names them by its own ids, so
-        // the edited files cannot be mapped onto the original's directories.
-        const res = resourceChanges(base, edited);
-        if (res) {
-            findings.push(finding(`agent "${node.id}": the edit changes its resource files (${res}). Merge does not carry resource files; `
-                + 'the original\'s stay as they are. Make that change on the canvas.'));
+        // Resources: carried by identity (#1221), when the three flows are known.
+        if (flows === undefined) {
+            const res = resourceChanges(base, edited);
+            if (res) {
+                findings.push(finding(`agent "${node.id}": the edit changes its resource files (${res}). Merge does not carry resource files; `
+                    + 'the original\'s stay as they are. Make that change on the canvas.'));
+            }
+            continue;
+        }
+        const carriedResources = carryResources(source, { original: orig, baseline: base, edited }, flows);
+        writes.push(...carriedResources.writes);
+        removals.push(...carriedResources.removals);
+        for (const path of carriedResources.unmatched) {
+            findings.push(finding(`agent "${node.id}": the edit changes or removes the resource ${path}, but merge cannot tell which of the `
+                + 'original\'s resource directories it is (no original node has the id of the node that names it, and no '
+                + 'original resource file has its content), so the change is NOT carried and the original\'s resource files '
+                + 'stay as they are. Make that change on the canvas.'));
         }
     }
-    return { writes, findings };
+    return { writes, removals, findings };
 }

package/dist/merge.d.ts

@@ -176,4 +176,5 @@ export declare function mergeFlow(original: AnyFlow, edited: AnyFlow, options?:
 export declare function mergeFlowWithSidecars(original: AnyFlow, edited: AnyFlow, sidecars: MergeSidecarSources, options?: MergeOptions): {
     flow: AnyFlow;
     sidecars: SidecarWrite[];
+    removals: string[];
 };

package/dist/merge.js

@@ -140,6 +140,38 @@ function withOriginalLayout(edited, orig, originalLayout) {
     }
     return edited;
 }
+/**
+ * Give an edited node the original's `inputs.source` when only the round trip
+ * changed it (the baseline's equals the edited one's).
+ *
+ * `source` names the directory of a node's sidecar files: an agent's
+ * `<source>/agent.json`, an agent resource's `<agent>/resources/<source>/`.
+ * Decompile keeps an agent's, but compile derives a resource's from the step
+ * and the resource, so the canvas's `resources/d84e2c17-…/` comes back as
+ * `resources/e3ed6f35-…/`. An edited resource node taken whole would then name
+ * a directory the project does not have. The author never writes a resource's
+ * `source`, so keeping the original's is the delta rule (#1221); merge-sidecars
+ * writes the carried file back under that same directory.
+ */
+function withOriginalSource(node, orig, base) {
+    const o = orig?.inputs?.source;
+    const e = node.inputs?.source;
+    if (typeof o !== 'string' || typeof e !== 'string' || o === e || base?.inputs?.source !== e)
+        return node;
+    return { ...node, inputs: { ...node.inputs, source: o } };
+}
+/** {@link withOriginalSource} over every subflow node the original subflow of the same key also has. */
+function keepOriginalSourcesInSubflows(original, subflows, baseline) {
+    for (const [key, sf] of Object.entries(subflows)) {
+        const nodes = sf?.nodes;
+        if (!Array.isArray(nodes))
+            continue;
+        const origNodes = byId(original.subflows?.[key]?.nodes);
+        const baseNodes = byId(baseline.subflows?.[key]?.nodes);
+        for (let i = 0; i < nodes.length; i++)
+            nodes[i] = withOriginalSource(nodes[i], origNodes.get(nodes[i].id), baseNodes.get(nodes[i].id));
+    }
+}
 /** The original's `layout.nodes` map, when it has one. */
 function layoutNodesOf(f) {
     const nodes = f.layout?.nodes;
@@ -160,9 +192,9 @@ export function mergeFlow(original, edited, options = {}) {
  */
 export function mergeFlowWithSidecars(original, edited, sidecars, options = {}) {
     const { result, findings } = mergeFlowFindings(original, edited, options);
-    const carried = mergeAgentSidecars(result, sidecars);
+    const carried = mergeAgentSidecars(result, sidecars, { original, baseline: options.baseline, edited });
     reportOrRefuse([...findings, ...carried.findings], options);
-    return { flow: result, sidecars: carried.writes };
+    return { flow: result, sidecars: carried.writes, removals: carried.removals };
 }
 /** Warn every finding; under `strict`, throw over the refusing ones (and still warn the rest). */
 function reportOrRefuse(findings, options) {
@@ -189,7 +221,7 @@ function mergeFlowFindings(original, edited, options) {
         }
         else {
             // Added or edited → take the edited node, re-attaching original layout.
-            finalNodes.push(withOriginalLayout(jsonClone(e), orig, layoutNodesOf(original)));
+            finalNodes.push(withOriginalSource(withOriginalLayout(jsonClone(e), orig, layoutNodesOf(original)), orig, baseNodes.get(e.id)));
             if (orig && orig.type === e.type && orig.typeVersion !== e.typeVersion) {
                 options.warn?.(`node ${JSON.stringify(e.id)} moved ${e.type}@${String(orig.typeVersion)} -> ${String(e.typeVersion)} `
                     + `(the edited source does not pin ${String(orig.typeVersion)}; keep the { version } pin, `
@@ -203,6 +235,8 @@ function mergeFlowFindings(original, edited, options) {
     // ── Variables & subflows: the edited flow is authoritative (the user's graph). ──
     result.variables = jsonClone(edited.variables);
     result.subflows = jsonClone(edited.subflows ?? {});
+    if (options.baseline)
+        keepOriginalSourcesInSubflows(original, result.subflows, options.baseline);
     const subflowScopes = Object.values(result.subflows);
     // ── Edges: the edited graph's edges define the wiring, under the edited
     //    file's own ids. compile draws every edge id — root AND subflows — from

package/dist/project-resource-users.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The `inputs.source` uuids the OTHER `.flow` files in `dir` reference, each
+ * mapped to the first file that does. `dir` is the namespace sidecar paths are
+ * relative to, so these are the agent resources another flow still uses. The
+ * flow being written (`self`) is left out: what it no longer references is what
+ * pruning is for. Subflow bodies are included; an unreadable file contributes
+ * nothing.
+ */
+export declare function resourceSourcesOfOtherFlows(dir: string, self: string): Map<string, string>;

package/dist/project-resource-users.js

@@ -0,0 +1,47 @@
+/**
+ * project-resource-users — which other `.flow` files in a Flow project still
+ * use a sidecar directory. Compile's prune and merge's resource removal both
+ * must leave such a directory alone: a decompiled canvas agent keeps its
+ * `source` directory, so two flows in one project can share it (#1151, #1184).
+ */
+import { readdirSync, readFileSync } from 'node:fs';
+import { join, resolve } from 'node:path';
+/**
+ * The `inputs.source` uuids the OTHER `.flow` files in `dir` reference, each
+ * mapped to the first file that does. `dir` is the namespace sidecar paths are
+ * relative to, so these are the agent resources another flow still uses. The
+ * flow being written (`self`) is left out: what it no longer references is what
+ * pruning is for. Subflow bodies are included; an unreadable file contributes
+ * nothing.
+ */
+export function resourceSourcesOfOtherFlows(dir, self) {
+    const users = new Map();
+    let entries;
+    try {
+        entries = readdirSync(dir).filter((f) => f.endsWith('.flow') && resolve(dir, f) !== self);
+    }
+    catch {
+        return users;
+    }
+    for (const f of entries) {
+        let flow;
+        try {
+            flow = JSON.parse(readFileSync(join(dir, f), 'utf8'));
+        }
+        catch {
+            continue;
+        }
+        const walk = (scope) => {
+            const s = scope;
+            for (const n of Array.isArray(s?.nodes) ? s.nodes : []) {
+                const src = n?.inputs?.source;
+                if (typeof src === 'string' && !users.has(src))
+                    users.set(src, f);
+            }
+            if (s?.subflows && typeof s.subflows === 'object')
+                Object.values(s.subflows).forEach(walk);
+        };
+        walk(flow);
+    }
+    return users;
+}

package/dist/serialize.js

@@ -10,7 +10,7 @@ import ixpDefinition from './ixp-definition.json' with { type: 'json' };
 import { BUNDLED_DEFINITIONS, bundledVersions } from './flow-definitions.js';
 import { Expr, toExpr, SCHEDULE_PRESETS, parseIxpProjectType, flatNameOf, flatNameSegmentsOf } from './flow-sdk.js';
 import { FlowAction, FlowTrigger } from './core/node-classes.js';
-import { contextIndexType } from './core/context-index.js';
+import { CONTEXT_INDEX_DEFAULTS, CONTEXT_INDEX_DEFAULT_FILE_EXTENSION, contextIndexType } from './core/context-index.js';
 import { connectorRawNodeRefusal } from './core/connector-raw-node.js';
 import { rawNodeInputProblem, registeredRawType } from './raw-node-advice.js';
 import { planContributionBindings } from './core/contribution-bindings.js';
@@ -855,19 +855,6 @@ function renderContextQuery(query, rename) {
     }
     return { ...base, promptValue: asText };
 }
-/**
- * The file extension each retrieval mode accepts by default. The platform's
- * manifest defaults every mode's NODE to `All`, but its resource schema pins
- * `structured`/`batchtransform` to `csv` and `deeprag` to `pdf`/`txt` — so a
- * flat `All` default would emit a resource the platform refuses to parse for
- * every mode but `semantic`.
- */
-const DEFAULT_FILE_EXTENSION = {
-    semantic: 'All',
-    structured: 'csv',
-    deeprag: 'pdf',
-    batchtransform: 'csv',
-};
 /**
  * The `resources/<id>/resource.json` an inline agent's context index needs.
  *
@@ -891,7 +878,7 @@ const DEFAULT_FILE_EXTENSION = {
  * every other binding with it.
  */
 function contextResourceJson(cx, spec) {
-    const mode = cx.retrievalMode ?? 'semantic';
+    const mode = cx.retrievalMode ?? CONTEXT_INDEX_DEFAULTS.retrievalMode;
     return {
         $resourceType: 'context',
         id: spec.id,
@@ -920,10 +907,12 @@ function contextResourceJson(cx, spec) {
             query: spec.query.mode === 'text-builder'
                 ? { variant: 'static', value: String(spec.query.textValue ?? '') }
                 : { variant: 'dynamic', description: String(spec.query.promptValue ?? '') },
-            folderPathPrefix: { variant: 'static' },
-            threshold: cx.threshold ?? 0,
-            resultCount: cx.resultCount ?? 3,
-            fileExtension: { value: cx.fileExtension ?? ownEntry(DEFAULT_FILE_EXTENSION, mode) ?? 'All' },
+            // `value: ''`, as the canvas writes it (flow-workbench `mapContextQueryToWire`
+            // always sets the value), so a canvas index's resource round-trips unchanged.
+            folderPathPrefix: { variant: 'static', value: '' },
+            threshold: cx.threshold ?? CONTEXT_INDEX_DEFAULTS.threshold,
+            resultCount: cx.resultCount ?? CONTEXT_INDEX_DEFAULTS.resultCount,
+            fileExtension: { value: cx.fileExtension ?? ownEntry(CONTEXT_INDEX_DEFAULT_FILE_EXTENSION, mode) ?? 'All' },
             // Mode-specific keys the schema REQUIRES of those two modes and rejects
             // nowhere else, carrying the node's own constants through the enum's
             // spelling (the node says `enabled`; the resource says `Enabled`/`Inline`).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.30.2",
+  "version": "6.30.4",
   "description": "Build UiPath Flow, Case, and BPMN artifacts by writing TypeScript.",
   "license": "MIT",
   "homepage": "https://docs.uipath.com/maestro",
@@ -92,5 +92,5 @@
     "@types/node": "^22.7.0",
     "esbuild": "^0.28.1"
   },
-  "gitref": "dcf5c8c2813ef37768cf148cd82cc27791621715"
+  "gitref": "09ce362aa97a2af0513e0c5883ccaa032df52a4a"
 }