@uipath/maestro-builder-sdk 6.12.1 → 6.13.0

package/README.md

@@ -128,9 +128,9 @@ reports its lookups as unresolved no matter how many times you prepare.
 
 It does three things, all of them on disk:
 
-- finds the connection and writes its ids into `bindings.json`, so the symbolic
+- finds the connection and writes its ids into `.flow-sdk/bindings.json`, so the symbolic
   `slack` and `shared` names in the code resolve;
-- records each answered lookup in `connectors-local/`, so compiling stays
+- records each answered lookup in `.flow-sdk/connectors-local/`, so compiling stays
   offline and repeatable;
 - writes the connection-resolved field schema for that operation, which is how
   a field the static library does not know about becomes compilable at all.
@@ -265,11 +265,51 @@ Exact signatures travel with the package, as TSDoc on the declarations in
 symbol, surfaced by an editor on hover. The authoring guides carry the same
 reference as Markdown.
 
+## Where authoring files go
+
+Authoring writes files that Studio Web never reads. By default they all go in
+one hidden folder, `.flow-sdk/`, in the directory you run the command from:
+
+| File | Written by |
+| --- | --- |
+| `.flow-sdk/<Name>.flow.ts` | `decompile` without `-o` |
+| `.flow-sdk/<Name>.pipeline.mjs`, `<Name>.baseline.flow` / `.edited.flow` / `.merged.flow` | `decompile` (the brownfield helper and the candidates it writes) |
+| `.flow-sdk/bindings.json` | `registry prepare` (read by `check` and `compile`) |
+| `.flow-sdk/connectors/` | `registry pull` |
+| `.flow-sdk/connectors-local/` | `registry prepare` (read by `check` and `compile`) |
+
+The product files are written where `compile -o` points, as before: the
+`.flow`, plus `bindings_v2.json` and an inline agent's folder beside it.
+
+The reason is packaging. `uip solution pack` copies every root-level file of a
+Flow project into the package, but no subfolder other than `content/`. So a
+project authored in place used to ship its `.flow.ts`, `bindings.json` and
+connector modules. Under `.flow-sdk/` they stay out.
+
+For example, authoring inside a project folder:
+
+```
+MySolution/MyFlow/
+├── MyFlow.flow            ← compile -o MyFlow.flow   (shipped)
+├── project.uiproj, operate.json, bindings_v2.json    (shipped)
+└── .flow-sdk/                                        (not packed)
+    ├── MyFlow.flow.ts, MyFlow.pipeline.mjs
+    ├── bindings.json
+    └── connectors/, connectors-local/
+```
+
+A source kept in `.flow-sdk/` imports its connectors as `./connectors/<key>.ts`,
+the same relative path as before. An explicit flag (`-o`, `--bindings`,
+`--connectors`, `--connectors-local`, `--out`) still wins. A workspace that
+already has a root-level `bindings.json`, `connectors/` or `connectors-local/`
+keeps using it, so nothing moves under an existing project.
+
 ## Integration Service connectors
 
-A flow that calls a connector needs a `bindings.json` alongside it, mapping the
+A flow that calls a connector needs a `bindings.json` mapping the
 symbolic `connection` / `folder` names in the code — `slack` and `shared` in the
-quick start — to real ids. `registry prepare` writes it; this is the shape, if
+quick start — to real ids. `registry prepare` writes it to `.flow-sdk/bindings.json`
+(see [Where authoring files go](#where-authoring-files-go)); this is the shape, if
 you would rather fill it from
 `uip is connections list --all-folders --output json`:
 

package/dist/bpmn/compile-cli.js

@@ -20,6 +20,7 @@ import { Bindings } from '../core/bindings.js';
 import { runWhenInvokedDirectly } from '../cli-run.js';
 import { ensureTypeScriptRuntime } from '../node-runtime.js';
 import { resolveLibraryDir } from '../registry/cache.js';
+import { defaultBindingsFile } from '../workdir.js';
 function opt(argv, name) {
     const i = argv.indexOf(name);
     return i >= 0 ? argv[i + 1] : undefined;
@@ -49,7 +50,7 @@ export async function run(argv) {
     // compile-cli); load it only when present, and bindings.json alongside the .ts.
     const libDir = resolveLibraryDir(opt(argv, '--library'));
     const library = libDir && existsSync(join(libDir, 'index.json')) ? new Library(libDir) : undefined;
-    const bindFile = opt(argv, '--bindings') ?? (existsSync('bindings.json') ? 'bindings.json' : undefined);
+    const bindFile = opt(argv, '--bindings') ?? defaultBindingsFile();
     const bindings = new Bindings(bindFile);
     const xml = await serialize(built, { library, bindings });
     const base = basename(file).replace(/\.bpmn\.ts$|\.ts$/, '');

package/dist/bpmn/decompile-cli.js

@@ -25,6 +25,7 @@ import { reportResult } from '../cli-result.js';
 import { typeStripDecision } from '../node-runtime.js';
 import { readFileSync, writeFileSync } from 'node:fs';
 import { basename, resolve } from 'node:path';
+import { defaultSourceOut } from '../workdir.js';
 import { runWhenInvokedDirectly } from '../cli-run.js';
 import { decompile } from './decompile.js';
 import { sameGraph } from './lift-verify.js';
@@ -98,7 +99,7 @@ export async function run(argv) {
         }
     }
     const base = basename(input).replace(/\.bpmn$/, '');
-    const out = opt(argv, '-o') ?? `${base}.bpmn.ts`;
+    const out = opt(argv, '-o') ?? defaultSourceOut(`${base}.bpmn.ts`);
     writeFileSync(out, source);
     console.log(`decompile: wrote ${out}`);
     if (lifted) {

package/dist/case/compile-cli.js

@@ -20,6 +20,7 @@ import { entryPointIO } from './entry-points.js';
 import { Library } from '../core/library.js';
 import { Bindings } from '../core/bindings.js';
 import { resolveLibraryDir } from '../registry/cache.js';
+import { defaultBindingsFile, defaultOverlayDir } from '../workdir.js';
 import { runWhenInvokedDirectly } from '../cli-run.js';
 import { ensureTypeScriptRuntime } from '../node-runtime.js';
 import { CASE_FORMAT_PROFILE } from './format-profile.js';
@@ -57,9 +58,9 @@ export async function run(argv) {
     const libDir = resolveLibraryDir(opt(argv, '--library'));
     // A `prepare-connector` overlay, auto-detected next to the case (like bindings.json).
     const overlayDir = opt(argv, '--connectors-local')
-        ?? (existsSync(join('connectors-local', 'index.json')) ? 'connectors-local' : undefined);
+        ?? defaultOverlayDir();
     const library = libDir && existsSync(join(libDir, 'index.json')) ? new Library(libDir, { overlayDir }) : undefined;
-    const bindFile = opt(argv, '--bindings') ?? (existsSync('bindings.json') ? 'bindings.json' : undefined);
+    const bindFile = opt(argv, '--bindings') ?? defaultBindingsFile();
     const bindings = new Bindings(bindFile);
     const caseplan = serialize(built, { library, bindings });
     const out = opt(argv, '-o') ?? 'caseplan.json';

package/dist/case/decompile-cli.js

@@ -16,9 +16,10 @@
  * through the public Case CLI. Pass `--no-pipeline` to skip it.
  */
 import { reportResult } from '../cli-result.js';
-import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { mkdirSync, existsSync, readFileSync, writeFileSync } from 'node:fs';
 import { resolveLibraryDir } from '../registry/cache.js';
-import { basename, resolve } from 'node:path';
+import { basename, join, resolve } from 'node:path';
+import { defaultSourceOut, workDirBeside } from '../workdir.js';
 import { runWhenInvokedDirectly } from '../cli-run.js';
 import { Library } from '../core/library.js';
 import { decompileWithDiagnostics } from './decompile.js';
@@ -64,7 +65,7 @@ export function run(argv) {
         library,
         bestEffort,
     });
-    const out = opt(argv, '-o') ?? `${baseName(plan)}.case.ts`;
+    const out = opt(argv, '-o') ?? defaultSourceOut(`${baseName(plan)}.case.ts`);
     writeFileSync(out, result.source);
     console.log(`decompile: wrote ${basename(out)}`);
     reportResult({ path: resolve(out), diagnostics: result.diagnostics.map((d) => ({ code: d.code, location: d.location, message: d.message })) });
@@ -72,8 +73,11 @@ export function run(argv) {
         console.error(`decompile: [${diagnostic.code}] ${diagnostic.location}: ${diagnostic.message}`);
     }
     if (!argv.includes('--no-pipeline')) {
-        const pipelinePath = out.replace(/\.case\.ts$|\.ts$/, '') + '.pipeline.mjs';
-        writeFileSync(pipelinePath, pipelineScript(resolve(pos), resolve(out), importSpecifier, bestEffort, libraryDir ? resolve(libraryDir) : undefined));
+        // The helper and the candidate caseplan it writes are never shipped.
+        const workDir = workDirBeside(out);
+        mkdirSync(workDir, { recursive: true });
+        const pipelinePath = join(workDir, basename(out).replace(/\.case\.ts$|\.ts$/, '') + '.pipeline.mjs');
+        writeFileSync(pipelinePath, pipelineScript(resolve(pos), resolve(out), resolve(pipelinePath), importSpecifier, bestEffort, libraryDir ? resolve(libraryDir) : undefined));
         console.log(`decompile: wrote ${basename(pipelinePath)}`);
         reportResult({ pipeline: resolve(pipelinePath) });
     }
@@ -85,8 +89,8 @@ export function run(argv) {
  * feeding the original caseplan back as the binding registry; this preserves
  * the resource keys that the typed source deliberately names symbolically.
  */
-function pipelineScript(originalPath, tsPath, importSpecifier, bestEffort, libraryDir) {
-    const base = tsPath.replace(/\.case\.ts$|\.ts$/, '');
+function pipelineScript(originalPath, tsPath, pipelinePath, importSpecifier, bestEffort, libraryDir) {
+    const base = pipelinePath.replace(/\.pipeline\.mjs$/, '');
     return `#!/usr/bin/env node
 // Generated by case decompile — edit ${basename(tsPath)}, then run this file.
 import { execFileSync, spawnSync } from 'node:child_process';

package/dist/check-cli.js

@@ -6,7 +6,7 @@
  * Prints diagnostics; exits non-zero if any errors.
  */
 import { reportDiagnostics } from './cli-result.js';
-import { existsSync } from 'node:fs';
+import { defaultBindingsFile } from './workdir.js';
 import { resolveFlowFile, loadBuiltFlow } from './load.js';
 import { check } from './check.js';
 import { byoaCheckOpts, eventResolveErrorFor, openCliLibrary } from './cli-library.js';
@@ -28,10 +28,10 @@ const VALUE_FLAGS = new Set(['--library', '--bindings', '--connectors-local']);
  * through the same `openCliLibrary`.
  */
 function checkOpts(argv) {
-    // bindings.json beside the source, exactly as compile-cli finds it — so the
+    // The default bindings.json (workdir.ts), exactly as compile-cli finds it — so the
     // own-name refusal compile would raise is reported here first.
     const bindFlag = argv.indexOf('--bindings');
-    const bindFile = bindFlag >= 0 ? argv[bindFlag + 1] : (existsSync('bindings.json') ? 'bindings.json' : undefined);
+    const bindFile = bindFlag >= 0 ? argv[bindFlag + 1] : defaultBindingsFile();
     const bindings = bindFile ? new Bindings(bindFile) : undefined;
     // The overlay matters here as much as it does for compile: `resolutions.json`
     // lives in it, and without it every already-resolved lookup would be reported

package/dist/cli/commands/registry.js

@@ -19,7 +19,7 @@ export function registerRegistryCommands(program) {
         .description('Download the published connector library and generate its Markdown and TypeScript views.')
         .option('--library <dir>', 'where library-json lands (default: ./library)')
         .option('--library-md <dir>', 'markdown output (default: ./library-md)')
-        .option('--connectors <dir>', 'TypeScript descriptor output (default: ./connectors)')
+        .option('--connectors <dir>', 'TypeScript descriptor output (default: ./.flow-sdk/connectors)')
         .option('--connector <key>', 'only generate this connector (repeatable; default: whatever the project references)', collect, [])
         .option('--url <url>', 'archive URL to pull from')
         .option('--archive <zip>', 'use a zip already on disk instead of downloading')
@@ -122,7 +122,7 @@ export function registerRegistryCommands(program) {
         await invoke('registry build-library', () => loadTool(import.meta.url, '../../registry/library-build/cli.js'), argv);
     });
     family.command('prepare')
-        .description("Resolve one operation's schema against a live connection into ./connectors-local.")
+        .description("Resolve one operation's schema against a live connection into ./.flow-sdk/connectors-local.")
         .argument('<connector-key>', 'connector key, e.g. uipath-salesforce')
         .option('--action <name>', '(required) operation to resolve, e.g. InsertRecord')
         .allowExcessArguments()
@@ -131,7 +131,7 @@ export function registerRegistryCommands(program) {
         .option('--connection-id <id>', 'connection to read the schema through')
         .option('--connection <name>', 'pick the connection by name when several match')
         .option('--connection-folder <folder>', 'pick the connection in the folder the flow runs in (name or key) when several match')
-        .option('--bindings <file>', 'bindings file to update (default: ./bindings.json)')
+        .option('--bindings <file>', 'bindings file to update (default: ./.flow-sdk/bindings.json)')
         .option('--bind-connection <name>', 'symbolic connection name (default: the one label the source uses for this connector, else the connector suffix)')
         .option('--bind-folder <name>', 'symbolic folder name (default: the one folder label the source uses, else shared)')
         // A SEPARATE key, not commander's negation of `--bindings`: sharing one key
@@ -142,7 +142,7 @@ export function registerRegistryCommands(program) {
         .option('--object <name>', 'one connection-discovered object')
         .option('--all-objects', 'every connection-discovered object')
         .option('-f, --field <name=value>', 'parent field that selects the schema (repeatable)', collect, [])
-        .option('--out <dir>', 'overlay directory (default: ./connectors-local)')
+        .option('--out <dir>', 'overlay directory (default: ./.flow-sdk/connectors-local)')
         // Not `--version`: the program's own version option shadows a subcommand's,
         // so `prepare --version 2.0` printed the package version instead of parsing.
         .option('--connector-version <version>', 'connector version to resolve against')

package/dist/cli-library.d.ts

@@ -5,7 +5,7 @@ import { Library } from './library.js';
  *
  * `--library <dir>`, else `$FLOW_SDK_LIBRARY_JSON`, else the cache `registry
  * pull` filled (`resolveLibraryDir`). The overlay is `--connectors-local <dir>`,
- * else `./connectors-local` when it has an `index.json` — the directory
+ * else `.flow-sdk/connectors-local` (or a legacy `./connectors-local`) when it has an `index.json` — the directory
  * `registry prepare` writes by default.
  */
 export declare function openCliLibrary(argv: readonly string[]): Library | undefined;

package/dist/cli-library.js

@@ -13,6 +13,7 @@ import { existsSync } from 'node:fs';
 import { join } from 'node:path';
 import { Library } from './library.js';
 import { resolveLibraryDir } from './registry/cache.js';
+import { defaultOverlayDir } from './workdir.js';
 /** The value after `name` in `argv`, or `undefined`. */
 function flagValue(argv, name) {
     const i = argv.indexOf(name);
@@ -23,7 +24,7 @@ function flagValue(argv, name) {
  *
  * `--library <dir>`, else `$FLOW_SDK_LIBRARY_JSON`, else the cache `registry
  * pull` filled (`resolveLibraryDir`). The overlay is `--connectors-local <dir>`,
- * else `./connectors-local` when it has an `index.json` — the directory
+ * else `.flow-sdk/connectors-local` (or a legacy `./connectors-local`) when it has an `index.json` — the directory
  * `registry prepare` writes by default.
  */
 export function openCliLibrary(argv) {
@@ -31,7 +32,7 @@ export function openCliLibrary(argv) {
     if (!libDir || !existsSync(join(libDir, 'index.json')))
         return undefined;
     const overlayDir = flagValue(argv, '--connectors-local')
-        ?? (existsSync(join('connectors-local', 'index.json')) ? 'connectors-local' : undefined);
+        ?? defaultOverlayDir();
     return new Library(libDir, { overlayDir });
 }
 /**

package/dist/compile-cli.js

@@ -8,7 +8,7 @@
  *        [--no-check]
  *
  * --library defaults to $FLOW_SDK_LIBRARY_JSON; --bindings defaults to
- * ./bindings.json when present. Connector actions require a library.
+ * .flow-sdk/bindings.json (or a legacy ./bindings.json) when present. Connector actions require a library.
  *
  * `--no-check` skips the SDK's static `check()` pass and emits whatever
  * `.build()` produced. It exists for loops whose verification is somewhere else
@@ -28,6 +28,7 @@ import { Bindings } from './bindings.js';
 import { runWhenInvokedDirectly } from './cli-run.js';
 import { connectionResources, mergeBindingsV2, readBindingsV2 } from './bindings-v2.js';
 import { ensureTypeScriptRuntime } from './node-runtime.js';
+import { defaultBindingsFile } from './workdir.js';
 import { BindingRefusal } from './core/binding-messages.js';
 import { ByoaRefusal } from './core/byoa.js';
 function opt(argv, name) {
@@ -75,7 +76,7 @@ export async function run(argv) {
     // filled. Resolving through one helper is what stops `pull` and `compile`
     // disagreeing about where the library is — they did, and a pulled library was
     // invisible to this command. The `prepare-connector`/`prepare-trigger` overlay
-    // is `--connectors-local`, else `./connectors-local` (like bindings.json); it
+    // is `--connectors-local`, else `.flow-sdk/connectors-local` (like bindings.json); it
     // shadows the baked library with full, connection-resolved field schemas. See
     // core/library.ts (LibraryOpts.overlayDir). `check-cli` opens it the same way.
     //
@@ -88,7 +89,7 @@ export async function run(argv) {
     // library, and answering it from an assumption instead is what made
     // EVENT_NO_SCOPE an error for HTTP Webhook, whose only correct `where` is empty.
     const library = openCliLibrary(argv);
-    const bindFile = opt(argv, '--bindings') ?? (existsSync('bindings.json') ? 'bindings.json' : undefined);
+    const bindFile = opt(argv, '--bindings') ?? defaultBindingsFile();
     const bindings = new Bindings(bindFile);
     if (!noCheck) {
         const diags = check(built, library

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

@@ -42,6 +42,6 @@ export function connectorRawNodeRefusal(nodeType) {
         + `Author it as connector('${key}', '${action}', { ...inputs }, { connection: '<binding>', folder: '<binding>' }). `
         + `If compile then refuses an input the static library does not carry, run `
         + `\`${prepareCommand(key, action)}\` — it discovers the connection, writes bindings.json `
-        + `and loads the connection-resolved fields into ./connectors-local/ (add \`-f <parent>=<value>\`, e.g. `
+        + `and loads the connection-resolved fields into ./.flow-sdk/connectors-local/ (add \`-f <parent>=<value>\`, e.g. `
         + `\`-f entityName=<Entity>\`, when the operation's fields depend on a parent input).`);
 }

package/dist/decompile-cli.js

@@ -18,8 +18,9 @@
  * `--no-pipeline` to skip it.
  */
 import { reportResult } from './cli-result.js';
-import { readFileSync, writeFileSync } from 'node:fs';
-import { basename, resolve } from 'node:path';
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { basename, join, resolve } from 'node:path';
+import { defaultSourceOut, workDirBeside } from './workdir.js';
 import { decompile } from './decompile.js';
 import { resolveFlowRefs } from './ref-resolve.js';
 import { runWhenInvokedDirectly } from './cli-run.js';
@@ -65,13 +66,18 @@ export function run(argv) {
         // reads them before compile refuses.
         warn: (message) => console.error(`flow-decompile: warning: ${message}`),
     });
-    const out = opt(argv, '-o') ?? `${baseName(flow)}.flow.ts`;
+    const out = opt(argv, '-o') ?? defaultSourceOut(`${baseName(flow)}.flow.ts`);
     writeFileSync(out, ts);
     console.log(`flow-decompile: wrote ${basename(out)}`);
     reportResult({ path: resolve(out) });
     if (!argv.includes('--no-pipeline')) {
-        const pipelinePath = out.replace(/\.flow\.ts$|\.ts$/, '') + '.pipeline.mjs';
-        writeFileSync(pipelinePath, pipelineScript(resolve(pos), resolve(out)));
+        // The helper and the baseline/edited/merged candidates it writes are never
+        // shipped, so they go in the work directory even when `-o` put the source
+        // somewhere visible.
+        const workDir = workDirBeside(out);
+        mkdirSync(workDir, { recursive: true });
+        const pipelinePath = join(workDir, basename(out).replace(/\.flow\.ts$|\.ts$/, '') + '.pipeline.mjs');
+        writeFileSync(pipelinePath, pipelineScript(resolve(pos), resolve(out), resolve(pipelinePath)));
         console.log(`flow-decompile: wrote ${basename(pipelinePath)}`);
         reportResult({ pipeline: resolve(pipelinePath) });
     }
@@ -86,8 +92,8 @@ export function run(argv) {
  * CLI carrying those preview commands is installed, it falls back to the SDK's
  * retained `flow-sdk` bin from this workspace.
  */
-function pipelineScript(originalPath, tsPath) {
-    const base = tsPath.replace(/\.flow\.ts$|\.ts$/, '');
+function pipelineScript(originalPath, tsPath, pipelinePath) {
+    const base = pipelinePath.replace(/\.pipeline\.mjs$/, '');
     return `#!/usr/bin/env node
 // Generated by flow-decompile — the brownfield read/modify/write pipeline for
 // ${basename(originalPath)}. Run it, edit ${basename(tsPath)}, run it again.

package/dist/emit.d.ts

@@ -3,7 +3,7 @@ import type { SerializeOpts } from './serialize.js';
 export interface EmitFlowOpts extends SerializeOpts {
     /** Connector library dir; defaults to `$FLOW_SDK_LIBRARY_JSON`. */
     libraryDir?: string;
-    /** bindings.json path; defaults to `./bindings.json` when it exists. */
+    /** bindings.json path; defaults to `.flow-sdk/bindings.json` (or a legacy `./bindings.json`) when it exists. */
     bindingsFile?: string;
 }
 /** Serialize `built` and write it to `path`; returns the `.flow` JSON. */

package/dist/emit.js

@@ -14,7 +14,7 @@
  *
  * `emitFlow(built, path)` is that, with the two resolutions defaulted the same
  * way `compile-cli` defaults them — library from `$FLOW_SDK_LIBRARY_JSON`,
- * bindings from `./bindings.json` when it exists:
+ * bindings from `.flow-sdk/bindings.json` (or a legacy `./bindings.json`) when it exists:
  *
  * ```ts
  * export default emitFlow(flow('release-rollup')…build(), 'ReleaseRollup/ReleaseRollup.flow');
@@ -31,6 +31,7 @@ import { serialize } from './serialize.js';
 import { Library } from './library.js';
 import { Bindings } from './bindings.js';
 import { resolveLibraryDir } from './registry/cache.js';
+import { defaultBindingsFile } from './workdir.js';
 /**
  * Resolve the connector library the same way `compile-cli` does: only load it
  * when it is actually there, so a flow with no connectors emits fine without a
@@ -45,7 +46,7 @@ function defaultLibrary(dir) {
 }
 /** Serialize `built` and write it to `path`; returns the `.flow` JSON. */
 export function emitFlow(built, path, opts = {}) {
-    const bindFile = opts.bindingsFile ?? (existsSync('bindings.json') ? 'bindings.json' : undefined);
+    const bindFile = opts.bindingsFile ?? defaultBindingsFile();
     const flowJson = serialize(built, {
         library: opts.library ?? defaultLibrary(opts.libraryDir),
         bindings: opts.bindings ?? new Bindings(bindFile),

package/dist/registry/generators/markdown/sections/example.js

@@ -206,7 +206,7 @@ export function exampleLines(j, fields, symbol, invariant, v1def) {
     if (schemaDynamic && symbol) {
         // ONE ordering per page: the import fact stays; authoring comes first.
         if (pyTruthy(operation.objectFromDiscovery)) {
-            out.push("The descriptor comes from `./connectors-local/` and this " +
+            out.push("The descriptor comes from `./.flow-sdk/connectors-local/` and this " +
                 "import resolves only after " +
                 `\`npx flow-sdk registry prepare ${connectorKey} --action ${action} ` +
                 "--object <name>` runs. That never blocks authoring: write " +
@@ -215,7 +215,7 @@ export function exampleLines(j, fields, symbol, invariant, v1def) {
                 "names this exact prepare — then switch to this import.");
         }
         else {
-            out.push("The descriptor comes from `./connectors-local/` and this " +
+            out.push("The descriptor comes from `./.flow-sdk/connectors-local/` and this " +
                 "import resolves only after " +
                 `\`npx flow-sdk registry prepare ${connectorKey} --action ${action}\` ` +
                 "runs. That never blocks authoring: the fields in this " +

package/dist/registry/generators/markdown/sections/schema-dynamic.js

@@ -65,7 +65,7 @@ export function schemaDynamicLines(j, nodeType) {
     }
     out.push("> ```");
     out.push(">");
-    let overlay = "> It writes a `./connectors-local/` overlay the compiler " +
+    let overlay = "> It writes a `./.flow-sdk/connectors-local/` overlay the compiler " +
         "auto-detects (its fields are unioned onto this entry).";
     if (!discovery) {
         overlay +=

package/dist/registry/prepare/connections.js

@@ -21,7 +21,7 @@
  * a {@link UipClient} and hand the rows to them. Every refusal's text is kept
  * verbatim — agents read these messages and follow them.
  */
-import { existsSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
 import { dirname, join, resolve as resolvePath } from "node:path";
 import { pyJsonStringify } from "../codecs/pyjson.js";
 import { Refusal, messageOf } from "../errors.js";
@@ -473,6 +473,8 @@ export function mergeBindings(path, symbolicConnection, symbolicFolder, connecti
         }
     }
     const merged = mergeBindingsDocument(loaded, symbolicConnection, symbolicFolder, connection);
+    // The default lives in `.flow-sdk/`, which a fresh workspace does not have yet.
+    mkdirSync(dirname(path), { recursive: true });
     writeFileSync(path, formatBindings(merged.document), "utf8");
     return [merged.wroteConnection, merged.wroteFolder];
 }

package/dist/registry/prepare/handoff.js

@@ -17,6 +17,7 @@ import { readFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { relativePosix, toPosix } from "../compat/paths.js";
 import { pyStrip } from "../compat/pystr.js";
+import { isRelativeSpecifier } from "./source-import.js";
 import { descriptorUsageFallbackLines, descriptorUsageLines, descriptorUsageUnparsedLines } from "./messages.js";
 /**
  * `ConnectorValue<string>` → `string`, for the handoff skeleton. The generated
@@ -77,7 +78,7 @@ export function descriptorUsage(outDir, connectorKey, boundConnection = "<bindin
         exports = [];
     }
     let importPath = relativePosix(cwd, resolve(cwd, source));
-    if (!importPath.startsWith("."))
+    if (!isRelativeSpecifier(importPath))
         importPath = `./${importPath}`;
     const sourcePosix = toPosix(source);
     if (exports.length === 1) {

package/dist/registry/prepare/pipeline.d.ts

@@ -16,7 +16,7 @@ export interface PrepareOptions {
      * already records are tried before the ambiguity refusal.
      */
     connectionFolder?: string;
-    /** `--bindings` (default `./bindings.json`). */
+    /** `--bindings` (default `./.flow-sdk/bindings.json`, see {@link defaultBindingsOut}). */
     bindings?: string;
     /**
      * `--bind-connection`. Default: the one `connection:` label the source already
@@ -31,7 +31,7 @@ export interface PrepareOptions {
     allObjects?: boolean;
     /** `-f NAME=VALUE`, repeatable, in the order given. */
     fields?: readonly string[];
-    /** `--out` (default `./connectors-local`). */
+    /** `--out` (default `./.flow-sdk/connectors-local`, see {@link defaultOverlayOut}). */
     out?: string;
     /** `--source`: the `.flow.ts` whose import is repointed. */
     source?: string;
@@ -56,8 +56,17 @@ export interface PreparePorts {
     /** How the pasteable `registry prepare` is spelled in the notes. */
     prepareCommand?: string;
 }
-/** Where prepare writes its overlay when `--out` is not given. */
-export declare const DEFAULT_OVERLAY_DIR = "./connectors-local";
+/**
+ * Where prepare writes its overlay when `--out` is not given, as shown to the
+ * author: `./.flow-sdk/connectors-local`, or a legacy `./connectors-local` the
+ * workspace already has (workdir.ts).
+ */
+export declare function defaultOverlayOut(cwd: string): string;
+/**
+ * Where prepare records connection bindings when `--bindings` is not given:
+ * `./.flow-sdk/bindings.json`, or a legacy `./bindings.json` (workdir.ts).
+ */
+export declare function defaultBindingsOut(cwd: string): string;
 export interface PrepareReport {
     kind: "action" | "event";
     /** The node type the overlay entry is stored under (the WAIT form for an event). */

package/dist/registry/prepare/pipeline.js

@@ -25,7 +25,7 @@
  * file system is reached through paths resolved against `cwd`.
  */
 import { existsSync, readFileSync } from "node:fs";
-import { resolve } from "node:path";
+import { relative, resolve } from "node:path";
 import { GUID_RE } from "../../core/binding-messages.js";
 import { PACKAGE_NAME } from "../../package-name.js";
 import { afterLast } from "../compat/pystr.js";
@@ -49,8 +49,22 @@ import { retryOtherConnections } from "./retry.js";
 import { repointSource } from "./source-import.js";
 import { sourceBindingLabels } from "./source-labels.js";
 import { isPlainObject, pyGet, pyOr, pyPathJoin, pyPathlibStr, pyStrAny, pyTruthy } from "./support.js";
-/** Where prepare writes its overlay when `--out` is not given. */
-export const DEFAULT_OVERLAY_DIR = "./connectors-local";
+import { workPath } from "../../workdir.js";
+/**
+ * Where prepare writes its overlay when `--out` is not given, as shown to the
+ * author: `./.flow-sdk/connectors-local`, or a legacy `./connectors-local` the
+ * workspace already has (workdir.ts).
+ */
+export function defaultOverlayOut(cwd) {
+    return `./${relative(cwd, workPath("connectors-local", { cwd }))}`;
+}
+/**
+ * Where prepare records connection bindings when `--bindings` is not given:
+ * `./.flow-sdk/bindings.json`, or a legacy `./bindings.json` (workdir.ts).
+ */
+export function defaultBindingsOut(cwd) {
+    return `./${relative(cwd, workPath("bindings.json", { cwd }))}`;
+}
 function memoryCaches() {
     return { registry: new MemoryResponseCache(), is: new MemoryResponseCache(), connectors: new MemoryResponseCache() };
 }
@@ -107,7 +121,7 @@ function chooseLabels(options, ports) {
     const command = ports.prepareCommand ?? PREPARE_COMMAND;
     const labels = sourceBindingLabels({
         cwd: ports.cwd ?? process.cwd(),
-        out: options.out ?? DEFAULT_OVERLAY_DIR,
+        out: options.out ?? defaultOverlayOut(ports.cwd ?? process.cwd()),
         connectorKey: options.connectorKey,
         source: options.source,
     });
@@ -222,7 +236,7 @@ async function connect(options, ports) {
         return { connectionId, row };
     // Recorded on BOTH routes. Until 3.30.5 only discovery wrote it, and the
     // explicit-id route left the author hand-writing the id and folder key.
-    const bindingsShown = options.bindings ?? "./bindings.json";
+    const bindingsShown = options.bindings ?? defaultBindingsOut(ports.cwd ?? process.cwd());
     const bindingsPath = resolve(ports.cwd ?? process.cwd(), bindingsShown);
     if (labels.connectionFrom) {
         await refuseLabelOfAnotherConnector(ports.client, options.connectorKey, labels.connection, connectionId, bindingsPath, bindingsShown);
@@ -321,7 +335,7 @@ async function prepareOnConnection(options, ports, connected) {
     const { connectorKey, action } = options;
     const fieldPairs = options.fields ?? [];
     const parentFields = parseFields(fieldPairs);
-    const outShown = options.out ?? DEFAULT_OVERLAY_DIR;
+    const outShown = options.out ?? defaultOverlayOut(cwd);
     const out = resolve(cwd, outShown);
     const importSpecifier = options.importSpecifier ?? PACKAGE_NAME;
     const jsonOnly = options.jsonOnly ?? false;

package/dist/registry/prepare/source-import.d.ts

@@ -3,7 +3,11 @@
  * Anchored to a real import statement on purpose (see the module comment).
  */
 export declare const IMPORT_PATTERN: RegExp;
-/** Where a `.flow.ts` will not be: generated output and installed packages. */
+/**
+ * Where a `.flow.ts` will not be: generated output and installed packages.
+ * Matched by name at any depth, so `.flow-sdk/connectors/` is skipped too while
+ * a source kept in `.flow-sdk/` itself is found.
+ */
 export declare const SOURCE_SKIP_DIRS: ReadonlySet<string>;
 /**
  * `Path(p).resolve()` with `strict=False`: absolute, `..` collapsed, and
@@ -11,6 +15,8 @@ export declare const SOURCE_SKIP_DIRS: ReadonlySet<string>;
  * go through this, so `/var/...` and `/private/var/...` name one file.
  */
 export declare function canonicalPath(p: string): string;
+/** `./x`, `../x`, `.` or `..`: a path relative to the importing file, as Node reads one. */
+export declare function isRelativeSpecifier(specifier: string): boolean;
 /**
  * `_resolves_to`: does `specifier`, read from `source`, name the file `target`?
  * A bare package specifier never does — it is not our overlay.

package/dist/registry/prepare/source-import.js

@@ -23,13 +23,18 @@ import { readFileSync, readdirSync, realpathSync, statSync, writeFileSync } from
 import { basename, dirname, join, resolve } from "node:path";
 import { compareCodePoints } from "../compat/compare.js";
 import { relativePosix } from "../compat/paths.js";
+import { workPath } from "../../workdir.js";
 import { repointedLine, severalSourcesLine, sourceNotAFileLine } from "./messages.js";
 /**
  * `import … from "<specifier>"` — the specifier is group 3, quotes preserved.
  * Anchored to a real import statement on purpose (see the module comment).
  */
 export const IMPORT_PATTERN = /(^\s*import\s[^;'"]*?\sfrom\s*)(['"])([^'"]+)(\2)/gm;
-/** Where a `.flow.ts` will not be: generated output and installed packages. */
+/**
+ * Where a `.flow.ts` will not be: generated output and installed packages.
+ * Matched by name at any depth, so `.flow-sdk/connectors/` is skipped too while
+ * a source kept in `.flow-sdk/` itself is found.
+ */
 export const SOURCE_SKIP_DIRS = new Set(["node_modules", "connectors", "connectors-local", ".git"]);
 /**
  * `Path(p).resolve()` with `strict=False`: absolute, `..` collapsed, and
@@ -48,12 +53,16 @@ export function canonicalPath(p) {
         return join(canonicalPath(parent), basename(absolute));
     }
 }
+/** `./x`, `../x`, `.` or `..`: a path relative to the importing file, as Node reads one. */
+export function isRelativeSpecifier(specifier) {
+    return /^\.\.?(\/|$)/.test(specifier);
+}
 /**
  * `_resolves_to`: does `specifier`, read from `source`, name the file `target`?
  * A bare package specifier never does — it is not our overlay.
  */
 export function resolvesTo(specifier, source, target) {
-    if (!specifier.startsWith("."))
+    if (!isRelativeSpecifier(specifier))
         return false;
     return canonicalPath(resolve(dirname(source), specifier)) === canonicalPath(target);
 }
@@ -134,7 +143,9 @@ export function repointImport(source, baked, prepared) {
         return undefined;
     }
     let specifier = relativePosix(dirname(source), prepared);
-    if (!specifier.startsWith("."))
+    // `.flow-sdk/…` starts with a dot but is not relative: without `./` Node
+    // resolves it as a package name.
+    if (!isRelativeSpecifier(specifier))
         specifier = `./${specifier}`;
     let changed = false;
     const rewritten = text.replace(IMPORT_PATTERN, (whole, head, quote, spec, tail) => {
@@ -169,7 +180,8 @@ export function repointSource(options) {
     if (options.noSourceRewrite || !isFile(prepared))
         return [];
     const root = canonicalPath(cwd);
-    const baked = canonicalPath(join(root, "connectors", `${options.connectorKey}.ts`));
+    // Where `registry pull` put the module: `.flow-sdk/connectors/`, or a legacy `connectors/`.
+    const baked = canonicalPath(join(workPath("connectors", { cwd: root }), `${options.connectorKey}.ts`));
     let candidates;
     if (options.source) {
         candidates = [canonicalPath(resolve(cwd, options.source))];

package/dist/registry/prepare/source-labels.js

@@ -44,7 +44,8 @@ import { basename, dirname, extname, resolve } from "node:path";
 import * as ts from "typescript";
 import { GUID_RE } from "../../core/binding-messages.js";
 import { relativePosix } from "../compat/paths.js";
-import { canonicalPath, flowSources } from "./source-import.js";
+import { canonicalPath, flowSources, isRelativeSpecifier } from "./source-import.js";
+import { inWorkDir } from "../../workdir.js";
 const CALLEES = new Set(["connector", "onEvent", "waitForEvent"]);
 function isFile(path) {
     try {
@@ -58,7 +59,12 @@ function isFile(path) {
 export function sourceBindingLabels(options) {
     const result = { connection: new Map(), folder: new Map(), otherConnectors: new Map(), unreadable: { connection: [], folder: [] } };
     const root = canonicalPath(options.cwd);
-    const moduleDirs = [canonicalPath(resolve(root, "connectors")), canonicalPath(resolve(options.cwd, options.out))];
+    // `registry pull`'s modules in either layout (workdir.ts), and the overlay.
+    const moduleDirs = [
+        canonicalPath(inWorkDir("connectors", root)),
+        canonicalPath(resolve(root, "connectors")),
+        canonicalPath(resolve(options.cwd, options.out)),
+    ];
     let files;
     if (options.source) {
         const one = canonicalPath(resolve(options.cwd, options.source));
@@ -81,7 +87,7 @@ export function sourceBindingLabels(options) {
 }
 /** The connector key a module specifier names, when it is one of the generated connector modules. */
 function connectorModuleKey(specifier, from, moduleDirs) {
-    if (!specifier.startsWith("."))
+    if (!isRelativeSpecifier(specifier))
         return undefined;
     let target = canonicalPath(resolve(dirname(from), specifier));
     if (extname(target) === "")

package/dist/registry/prepare-cli.js

@@ -3,7 +3,7 @@ import { reportResult } from '../cli-result.js';
 import { PACKAGE_NAME } from "../package-name.js";
 import { exitCodeOf } from "./errors.js";
 import { exitText } from "./prepare/messages.js";
-import { DEFAULT_OVERLAY_DIR, prepareConnector as runPipeline } from "./prepare/pipeline.js";
+import { defaultOverlayOut, prepareConnector as runPipeline } from "./prepare/pipeline.js";
 import { consoleReporter } from "./reporter.js";
 import { defaultUipClient } from "./uip/client.js";
 // This mirrors the generator's own flags one for one, so a `--version` here is
@@ -187,7 +187,7 @@ export async function run(argv) {
     }
     try {
         const report = await prepareConnector(options);
-        reportResult({ connector: options.connectorKey, action: options.action, overlay: resolve(options.outPath ?? DEFAULT_OVERLAY_DIR), ...report });
+        reportResult({ connector: options.connectorKey, action: options.action, overlay: resolve(options.outPath ?? defaultOverlayOut(process.cwd())), ...report });
         return 0;
     }
     catch (error) {

package/dist/registry/pull-cli.js

@@ -6,6 +6,7 @@ import { CURRENT_LINK, LIBRARY_JSON_DIR, LIBRARY_MARKDOWN_DIR, cacheEntry, libra
 import { extractLibrary } from "./extractor.js";
 import { materializeRegistry } from "./materializer.js";
 import { curatedOverlayIdentity } from "./curated-overlay.js";
+import { WORK_DIR, workPath } from "../workdir.js";
 /**
  * Fetch the published connector library into the shared cache, and generate the
  * typed descriptors a project imports.
@@ -244,7 +245,8 @@ export async function run(argv) {
             console.error(`registry pull: ${flag} is ignored — the generators run in-process now and the flag will be removed.`);
         }
     }
-    const connectorsPath = value(argv, "--connectors") ?? "connectors";
+    // `.flow-sdk/connectors`, or a legacy `connectors/` the workspace already has.
+    const connectorsPath = value(argv, "--connectors") ?? workPath("connectors");
     try {
         const archive = await resolveArchive(argv, cacheDir, force);
         const archiveSha256 = await archiveIdentity(archive);
@@ -277,7 +279,10 @@ export async function run(argv) {
         // Which descriptors this project will actually import. Generating all 30
         // costs 1.1 MB in someone's repository for operations they never call.
         const named = repeated(argv, "--connector");
-        const referenced = named.length > 0 ? named : referencedConnectorKeys(".");
+        // Sources sit in the project root or in the hidden work directory.
+        const referenced = named.length > 0
+            ? named
+            : [...new Set([...referencedConnectorKeys("."), ...referencedConnectorKeys(WORK_DIR)])].sort();
         // Generate only what is missing. The Markdown is 2,472 pages and a pure
         // function of the library JSON, so regenerating it to add one descriptor is
         // pure waste — and it is what the first run of this design did.

package/dist/serialize.js

@@ -6417,7 +6417,7 @@ function buildConnectorInputs(rc, inputs, rename = NO_RENAME, resolutions = {},
                     `static library does not contain this input. Run ` +
                     `\`${prepareCommand(rc.connectorKey, action)}\` ` +
                     `to load them ` +
-                    `(writes ./connectors-local/, which the compiler auto-detects). If that still ` +
+                    `(writes ./.flow-sdk/connectors-local/, which the compiler auto-detects). If that still ` +
                     `does not carry this input, the operation resolves its fields from the VALUES of ` +
                     `parent inputs: resolve every parent and re-run with ` +
                     `\`-f <parent-field>=<value>\` for each — too few parents is refused, and a ` +

package/dist/workdir.d.ts

@@ -0,0 +1,35 @@
+/** The hidden directory, relative to the current directory. */
+export declare const WORK_DIR = ".flow-sdk";
+/** `name` under {@link WORK_DIR}, relative to `cwd` when one is given. */
+export declare function inWorkDir(name: string, cwd?: string): string;
+/**
+ * Where the default `name` lives for this workspace, for reading or writing.
+ *
+ * `.flow-sdk/<name>` when it exists; else the legacy `./<name>` when THAT exists
+ * (a workspace laid out before the work directory); else `.flow-sdk/<name>`,
+ * where a new file goes. Pass `exists` to require more than presence (an
+ * overlay counts only once it has its `index.json`).
+ */
+export declare function workPath(name: string, options?: {
+    cwd?: string;
+    exists?: (path: string) => boolean;
+}): string;
+/** {@link workPath} for a file that is only read: `undefined` when neither exists. */
+export declare function existingWorkPath(name: string, options?: {
+    cwd?: string;
+    exists?: (path: string) => boolean;
+}): string | undefined;
+/** The default author-side `bindings.json`, when there is one. */
+export declare function defaultBindingsFile(cwd?: string): string | undefined;
+/** The default `connectors-local/` overlay, once `registry prepare` has written its index. */
+export declare function defaultOverlayDir(cwd?: string): string | undefined;
+/** Create the work directory under `cwd` (default: the current directory). */
+export declare function ensureWorkDir(cwd?: string): void;
+/**
+ * The work directory that goes with an authored `path`: the directory `path` is
+ * already in when that is a work directory, else `.flow-sdk/` beside it. A
+ * decompile's `.pipeline.mjs` helper and the candidates it writes go here.
+ */
+export declare function workDirBeside(path: string): string;
+/** The default path of a decompiled source named `file`, creating the work directory. */
+export declare function defaultSourceOut(file: string): string;

package/dist/workdir.js

@@ -0,0 +1,96 @@
+/**
+ * The SDK's hidden work directory: where authoring files that never ship live.
+ *
+ * Authoring writes files the product never reads: the decompiled `<Name>.flow.ts`
+ * and its `.pipeline.mjs` helper, the `baseline`/`edited`/`merged` candidates, the
+ * author-side `bindings.json`, and the generated `connectors/` and
+ * `connectors-local/` modules. Studio Web needs none of them. The product files
+ * (`<Name>.flow`, `project.uiproj`, `operate.json`, `bindings_v2.json`, an inline
+ * agent's folder) are written where `compile -o` says, exactly as before.
+ *
+ * Every one of those defaults used to be a bare name in the current directory,
+ * so a project authored in place carried them into its package: `uip solution
+ * pack` copies every root-level file of a Flow project. Keeping them under one
+ * dot-folder keeps them out: pack copies no project subfolder but `content/`.
+ *
+ * Paths stay relative to the current directory, as the old defaults were, so
+ * `uip` (which spawns the SDK with the caller's cwd) and a direct `flow-sdk`
+ * call land in the same place. An explicit flag (`-o`, `--bindings`,
+ * `--connectors`, `--connectors-local`, `--out`) still wins.
+ *
+ * A workspace laid out before this directory existed keeps working: when only
+ * the old root-level entry exists, reads and writes use it (see
+ * {@link workPath}), so an existing `./connectors-local/` overlay is extended
+ * rather than split across two places. When both exist, `.flow-sdk/` wins and
+ * stderr says the root one is ignored.
+ */
+import { existsSync, mkdirSync } from 'node:fs';
+import { basename, dirname, join } from 'node:path';
+/** The hidden directory, relative to the current directory. */
+export const WORK_DIR = '.flow-sdk';
+/** `name` under {@link WORK_DIR}, relative to `cwd` when one is given. */
+export function inWorkDir(name, cwd) {
+    return cwd === undefined ? join(WORK_DIR, name) : join(cwd, WORK_DIR, name);
+}
+/**
+ * Where the default `name` lives for this workspace, for reading or writing.
+ *
+ * `.flow-sdk/<name>` when it exists; else the legacy `./<name>` when THAT exists
+ * (a workspace laid out before the work directory); else `.flow-sdk/<name>`,
+ * where a new file goes. Pass `exists` to require more than presence (an
+ * overlay counts only once it has its `index.json`).
+ */
+export function workPath(name, options = {}) {
+    const exists = options.exists ?? existsSync;
+    const current = inWorkDir(name, options.cwd);
+    const legacy = options.cwd === undefined ? name : join(options.cwd, name);
+    if (exists(current)) {
+        // Both present is how an edit goes missing: a guide still names the root
+        // file, the author edits it, and every command keeps reading this one.
+        if (exists(legacy))
+            noteShadowed(current, legacy);
+        return current;
+    }
+    return exists(legacy) ? legacy : current;
+}
+const noted = new Set();
+/** Say once per process that a root-level `legacy` is being ignored. */
+function noteShadowed(current, legacy) {
+    if (noted.has(legacy))
+        return;
+    noted.add(legacy);
+    console.error(`flow-sdk: using ${current}; ${legacy} is also present and is ignored. Move its contents into ${current}, or pass the path explicitly.`);
+}
+/** {@link workPath} for a file that is only read: `undefined` when neither exists. */
+export function existingWorkPath(name, options = {}) {
+    const exists = options.exists ?? existsSync;
+    const path = workPath(name, options);
+    return exists(path) ? path : undefined;
+}
+/** The default author-side `bindings.json`, when there is one. */
+export function defaultBindingsFile(cwd) {
+    return existingWorkPath('bindings.json', { cwd });
+}
+/** The default `connectors-local/` overlay, once `registry prepare` has written its index. */
+export function defaultOverlayDir(cwd) {
+    const exists = (dir) => existsSync(join(dir, 'index.json'));
+    return existingWorkPath('connectors-local', { cwd, exists });
+}
+/** Create the work directory under `cwd` (default: the current directory). */
+export function ensureWorkDir(cwd) {
+    mkdirSync(cwd === undefined ? WORK_DIR : join(cwd, WORK_DIR), { recursive: true });
+}
+/**
+ * The work directory that goes with an authored `path`: the directory `path` is
+ * already in when that is a work directory, else `.flow-sdk/` beside it. A
+ * decompile's `.pipeline.mjs` helper and the candidates it writes go here.
+ */
+export function workDirBeside(path) {
+    const dir = dirname(path);
+    return basename(dir) === WORK_DIR ? dir : join(dir, WORK_DIR);
+}
+/** The default path of a decompiled source named `file`, creating the work directory. */
+export function defaultSourceOut(file) {
+    ensureWorkDir();
+    return inWorkDir(file);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uipath/maestro-builder-sdk",
-  "version": "6.12.1",
+  "version": "6.13.0",
   "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": "9b83c4da2e3512512d5b128f43cc8f8f03b74555"
+  "gitref": "bf85d17e1d820f584329913c9ac836a2fbc23dec"
 }