@uipath/maestro-builder-sdk 6.30.1 → 6.30.3

package/dist/check.js

@@ -966,8 +966,10 @@ function checkFlow(built, ancestors, opts = {}) {
         // subflow read, where the value lives one level deeper
         // (`$vars.<call>.output.<childOutput>`). Every other rule reads only the
         // first two segments, exactly as before.
-        for (const m of js.matchAll(/\$vars\.([A-Za-z0-9_]+)(?:\.([A-Za-z0-9_]+))?((?:\.[A-Za-z0-9_]+)*)/g)) {
-            const [, name, field, rest] = m;
+        for (const m of js.matchAll(/\$vars\.([A-Za-z0-9_]+)(?:\??\.([A-Za-z0-9_]+))?((?:\??\.[A-Za-z0-9_]+)*)/g)) {
+            const [, name, field] = m;
+            // `?.` reads the same path as `.`, and the rules below parse the tail as `.a.b`.
+            const rest = m[3].replace(/\?\./g, '.');
             if (!declared.has(name)) {
                 const near = [...declared].find((d) => d.toLowerCase() === name.toLowerCase());
                 diags.push({

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/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/flow-sdk.d.ts

@@ -463,8 +463,9 @@ export interface ReturnOptions extends NodeOptions {
      *
      * @remarks
      * Like a step name this is identity, not decoration: use {@link NodeOptions.label}
-     * for what the canvas shows. Ids are de-duplicated, so two Ends both asking for
-     * `done` become `done` and `done2`.
+     * for what the canvas shows. Two Ends in one scope asking for `done` with the
+     * same values, label and version are one End reached from both paths; Ends that
+     * differ are de-duplicated to `done` and `done2`.
      *
      * ```ts
      * .branch('checkTemperature', js`${input('tempF')} > 60`,

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
@@ -234,6 +268,7 @@ function mergeFlowFindings(original, edited, options) {
     // ── Bindings: union by what each row binds (original wins), so resources for
     //    newly-added nodes come from `edited` while the original's stay intact. ──
     result.bindings = mergeBindings(original.bindings, edited.bindings);
+    result.bindings = withoutRowsKeyedOnlyByKeptNodes(result.bindings, original, edited, options.baseline);
     // metadata / solutionId / projectId / layout / runtime were carried by the
     // initial clone of `original` and are intentionally left untouched.
     //
@@ -373,3 +408,42 @@ function mergeBindings(orig, edited) {
     }
     return out;
 }
+/**
+ * Drop each added row that the no-edit recompile minted for a resource only
+ * nodes kept from the original spell. A row qualifies when the original lacks
+ * it, the baseline has it, and its `resourceKey` appears in at least one edited
+ * root node, every one of which the merge replaced with the original's: the kept
+ * node is the original's, and it reaches the resource without that row.
+ *
+ * Example: a classic-CLI IxP extract carries its model inline and has no
+ * binding rows. It decompiles to `ixpExtract(...)`, whose compile mints
+ * `ixpDeployment` `name` / `folderPath` rows keyed by the model id, and an
+ * untouched node would carry them into the merged file.
+ *
+ * A row whose key no edited node spells is kept, as are rows a subflow node or
+ * an edited node spells.
+ */
+function withoutRowsKeyedOnlyByKeptNodes(rows, original, edited, baseline) {
+    if (!baseline || !rows)
+        return rows;
+    const origNodes = byId(original.nodes);
+    const baseNodes = byId(baseline.nodes);
+    const nodes = [
+        ...(edited.nodes ?? []).map((n) => ({ kept: origNodes.has(n.id) && nodeUnchanged(n, baseNodes.get(n.id)), text: JSON.stringify(n) })),
+        ...Object.values(edited.subflows ?? {}).flatMap((sf) => (sf?.nodes ?? []).map((n) => ({ kept: false, text: JSON.stringify(n) }))),
+    ];
+    if (!nodes.some((n) => n.kept))
+        return rows;
+    const fromOriginal = new Set((original.bindings ?? []).map(bindingIdentity));
+    const inBaseline = new Set((baseline.bindings ?? []).map(bindingIdentity));
+    return rows.filter((b) => {
+        const identity = bindingIdentity(b);
+        if (fromOriginal.has(identity) || !inBaseline.has(identity))
+            return true;
+        if (typeof b.resourceKey !== 'string' || b.resourceKey === '')
+            return true;
+        const spelled = JSON.stringify(b.resourceKey).slice(1, -1);
+        const spellers = nodes.filter((n) => n.text.includes(spelled));
+        return !(spellers.length > 0 && spellers.every((n) => n.kept));
+    });
+}

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;
+}