@method-ai-hq/sdk 0.18.1 → 0.19.0

package/dist/packages/sdk/src/proposals.js

@@ -1,61 +1,11 @@
 import { existsSync, readdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from 'node:fs';
 import { basename, dirname, join } from 'node:path';
-import { isDeepStrictEqual, parseArgs } from 'node:util';
-import { loadWorkflow } from '../../workflow-language/src/validate.js';
+import { parseArgs } from 'node:util';
 import { authoringPath, readDocument, writeDocument } from './authoring.js';
 import { DEFAULT_SERVER } from './method-client.js';
 import { writePrivateJson } from './files.js';
-import { currentVersion, methodContent, methodIdPattern } from './versions.js';
+import { methodIdPattern } from './versions.js';
 import { localMethodFolder } from './local-judgments.js';
-const isObject = (value) => !!value && typeof value === 'object' && !Array.isArray(value);
-/** Keys of ours in their order; a key that only theirs has goes after the key before it in theirs. */
-function keyOrder(ours, theirs) {
-    const keys = Object.keys(ours), theirKeys = Object.keys(theirs);
-    theirKeys.forEach((key, index) => {
-        if (keys.includes(key))
-            return;
-        const before = theirKeys.slice(0, index).reverse().find(other => keys.includes(other));
-        keys.splice(before === undefined ? 0 : keys.indexOf(before) + 1, 0, key);
-    });
-    return keys;
-}
-/**
- * Three-way merge of Method documents, per step and per top-level key. base is the version the proposal started from,
- * ours is the local file, and theirs is the proposed version. A part that only one side changed takes that change; a part
- * that both sides changed in different ways is a conflict.
- */
-export function mergeMethod(base, ours, theirs) {
-    if (isDeepStrictEqual(ours, base))
-        return { clean: true, workflow: theirs };
-    if (isDeepStrictEqual(theirs, base) || isDeepStrictEqual(ours, theirs))
-        return { clean: true, workflow: ours };
-    const conflicts = [];
-    const pick = (path, b, o, t) => {
-        if (isDeepStrictEqual(o, t) || isDeepStrictEqual(b, t))
-            return o;
-        if (isDeepStrictEqual(b, o))
-            return t;
-        conflicts.push({ path, base: b, ours: o, theirs: t });
-        return o;
-    };
-    const merge = (path, b, o, t, nested) => {
-        const result = {};
-        for (const key of keyOrder(o, t)) {
-            const at = path ? `${path}.${key}` : key;
-            const value = nested(key) && isObject(o[key]) && isObject(t[key]) && isObject(b?.[key] ?? {})
-                ? merge(at, b?.[key] ?? {}, o[key], t[key], () => false) : pick(at, b?.[key], o[key], t[key]);
-            if (value !== undefined)
-                result[key] = value;
-        }
-        return result;
-    };
-    const workflow = merge('', isObject(base) ? base : {}, ours, theirs, key => key === 'steps');
-    return conflicts.length ? { clean: false, conflicts } : { clean: true, workflow };
-}
-/** The steps whose definition differs between two documents. */
-export function changedSteps(before, after) {
-    return [...new Set([...Object.keys(before?.steps ?? {}), ...Object.keys(after?.steps ?? {})])].filter(id => !isDeepStrictEqual(before?.steps?.[id], after?.steps?.[id]));
-}
 /** Write Method content to a file and keep its id: line. A JSON file stays JSON. */
 export function writeMethodFile(file, id, content) {
     const { format, ...rest } = content;
@@ -91,83 +41,6 @@ export function localProposals(file) {
         return { ...record, proposed_workflow: record.proposed_workflow ?? null, path };
     }).filter(record => record.file === basename(file)).sort((a, b) => String(b.created_at).localeCompare(String(a.created_at)));
 }
-async function accountProposal(client, id, options = {}) {
-    const { proposal } = await client.request(`/api/proposals/${encodeURIComponent(id)}`, 'GET', undefined, true, options);
-    return { ...proposal, source: 'account', proposed_workflow: proposal.proposed_workflow ?? null };
-}
-async function newestAccepted(client, methodId, options = {}) {
-    const { proposals } = await client.request(`/api/methods/${encodeURIComponent(methodId)}/proposals?status=accepted`, 'GET', undefined, true, options);
-    const accepted = (proposals ?? []).filter(p => p?.status === 'accepted').sort((a, b) => String(b.created_at).localeCompare(String(a.created_at)));
-    return accepted[0] ? accountProposal(client, accepted[0].id, options) : undefined;
-}
-/** Merge a change Method made in the account into the file. A clean merge writes the file and records the change as applied. Never publishes. */
-async function applyProposal(client, file, proposal, options = {}) {
-    const document = readDocument(file), ours = methodContent(document);
-    const merged = mergeMethod(proposal.base_workflow, ours, proposal.proposed_workflow);
-    if (!merged.clean)
-        return { status: 'conflict', conflicts: merged.conflicts };
-    try {
-        loadWorkflow(merged.workflow);
-    }
-    catch (error) {
-        return { status: 'invalid', error: error.message };
-    }
-    if (!isDeepStrictEqual(merged.workflow, ours))
-        writeMethodFile(file, typeof document.id === 'string' ? document.id : undefined, merged.workflow);
-    return { status: 'applied', steps: changedSteps(ours, merged.workflow), ...await markApplied(client, file, proposal, options) };
-}
-async function markApplied(client, file, proposal, options = {}) {
-    const version_id = (await currentVersion(file).catch(() => undefined))?.version_id;
-    try {
-        await client.request(`/api/proposals/${encodeURIComponent(proposal.id)}/applied`, 'POST', version_id ? { version_id } : {}, true, options);
-        return { version_id };
-    }
-    catch (error) {
-        return { version_id, warning: `The file is changed, but Method did not record the proposal as applied: ${error.message}` };
-    }
-}
-const serverFlag = (args) => { const at = args.findIndex(arg => arg === '--server' || arg.startsWith('--server=')); return at < 0 ? undefined : args[at].startsWith('--server=') ? args[at].slice(9) : args[at + 1]; };
-const skipAutoApply = new Set(['changes', 'judge', 'init', 'new-id', 'diff', 'help', 'authoring', 'schema', '__worker', '__checks', '__model', 'worker', 'keys', 'secret', 'models', 'login', 'logout', 'sync', 'progress']);
-/**
- * Before a command that takes a .method FILE: when this computer is signed in and Method changed the Method in the
- * account (keeping run data in the account, or a fix of a Method that had not run on a computer), merge the change into
- * the file and print one line. A conflict leaves the file unchanged and writes both versions of each conflicting part
- * to a file for the coding agent to merge; the command goes on. Offline, signed out, or on any error, it does nothing.
- */
-export async function autoApply(args, clientFactory) {
-    if (!args[0] || skipAutoApply.has(args[0]) || args.includes('--help') || process.env.METHOD_RUN_WORKER === '1')
-        return;
-    const target = args.slice(1).find(arg => !arg.startsWith('-') && /\.method$/i.test(arg));
-    if (!target || !existsSync(target))
-        return;
-    try {
-        const file = authoringPath(target), id = readDocument(file).id;
-        if (typeof id !== 'string' || !methodIdPattern.test(id))
-            return;
-        const client = clientFactory(serverFlag(args) ?? DEFAULT_SERVER);
-        if (!client.token())
-            return;
-        const options = { signal: AbortSignal.timeout(3000), stallMs: 3000 };
-        const proposal = await newestAccepted(client, id, options);
-        if (!proposal?.proposed_workflow)
-            return;
-        const result = await applyProposal(client, file, proposal, options);
-        if (result.status === 'applied') {
-            if (result.steps.length || result.warning)
-                process.stderr.write(`Method changed ${target} (${proposal.id}): ${proposal.cause}${result.steps.length ? ` Changed steps: ${result.steps.join(', ')}.` : ''}${result.warning ? ` ${result.warning}` : ''}\n`);
-            return;
-        }
-        // The agent merges by hand from the saved versions; the change is recorded as applied, so it is not merged again.
-        localMethodFolder(file);
-        const path = join(dirname(file), '.method', `conflict-${proposal.id}.json`);
-        writePrivateJson(path, { proposal_id: proposal.id, cause: proposal.cause, ...(result.status === 'conflict' ? { conflicts: result.conflicts } : { error: result.error }), proposed_workflow: proposal.proposed_workflow });
-        await markApplied(client, file, proposal, options).catch(() => undefined);
-        process.stderr.write(result.status === 'conflict'
-            ? `Method's change ${proposal.id} (${proposal.cause}) conflicts with your edits of ${target} in ${result.conflicts.map(c => c.path).join(', ')}. The file is not changed. Both versions of each part are in ${path}: edit ${target} so each part keeps both changes.\n`
-            : `Method's change ${proposal.id} does not merge into a valid Method: ${result.error} The file is not changed. The changed version is in ${path}.\n`);
-    }
-    catch { /* offline or signed out: the command goes on without the change. */ }
-}
 /** Run folders of this Method on this computer, newest first, with the account run ID of each run that was saved to the account. */
 export async function localRuns(file) {
     const { recentRuns } = await import('./current-runtime.js');

package/dist/packages/sdk/src/quality.d.ts

@@ -1,3 +1,4 @@
+import { MethodClient } from "./method-client.js";
 /** The same runtime preparation as method run, without starting a run. Hosted models are used when signed in. */
 export declare function preparedConfig(file: string, flags: {
     workspace?: string;
@@ -16,8 +17,16 @@ export declare const defaultRunRoots: () => string[];
 export declare function observeCommand(args: string[]): Promise<void>;
 /** A fingerprint of a Method and the files it runs, to tell whether its cases were checked since the last change. */
 export declare function methodFingerprint(file: string): string;
-/** One line for method run when the Method changed since its cases last passed. */
+/** A case as a person reads it: "Gráinne's case dates-conflict: the note" when the case names who made it. */
+export declare const caseName: (c: {
+    id: string;
+    author?: string | null;
+    note?: unknown;
+}) => string;
+/** One line for method run when the Method changed since its cases last passed. Cases with an author are named. */
 export declare function casesNotice(file: string): Promise<string | undefined>;
+/** The name of the signed-in person, for the author of a new case; null when signed out or offline. Asked once per sign-in in a process. */
+export declare function signedInName(client?: Pick<MethodClient, "server" | "request" | "token">): Promise<string | null>;
 /** Run the cases of a Method with the same preparation as method run. */
 export declare function runCases(file: string, flags: {
     workspace?: string;

package/dist/packages/sdk/src/quality.js

@@ -125,7 +125,9 @@ function recordChecked(file, report) {
     mkdirSync(dirname(checkedFile(file)), { recursive: true, mode: 0o700 });
     writePrivateJson(checkedFile(file), { file, fingerprint: methodFingerprint(file), passed: report.passed, cases: report.cases.length, at: new Date().toISOString() });
 }
-/** One line for method run when the Method changed since its cases last passed. */
+/** A case as a person reads it: "Gráinne's case dates-conflict: the note" when the case names who made it. */
+export const caseName = (c) => `${c.author}'s case ${c.id}: ${String(c.note ?? "").slice(0, 200).replace(/[.\s]+$/, "")}`;
+/** One line for method run when the Method changed since its cases last passed. Cases with an author are named. */
 export async function casesNotice(file) {
     const cases = (await listCases(file)).filter((c) => c.status === "active");
     if (!cases.length)
@@ -137,7 +139,33 @@ export async function casesNotice(file) {
     catch { /* never checked */ }
     if (checked?.passed && checked.fingerprint === methodFingerprint(file))
         return undefined;
-    return `${cases.length} case${cases.length === 1 ? "" : "s"} not checked since this Method changed: method test ${file}`;
+    const named = cases.filter((c) => c.author);
+    return `${cases.length} case${cases.length === 1 ? "" : "s"} not checked since this Method changed${named.length ? ` (${named.map(caseName).join("; ")})` : ""}: method test ${file}`;
+}
+const signedIn = new Map();
+/** The name of the signed-in person, for the author of a new case; null when signed out or offline. Asked once per sign-in in a process. */
+export function signedInName(client = new MethodClient()) {
+    let token;
+    try {
+        token = client.token();
+    }
+    catch {
+        return Promise.resolve(null);
+    }
+    if (!token)
+        return Promise.resolve(null);
+    const key = `${client.server}\n${token}`;
+    if (!signedIn.has(key))
+        signedIn.set(key, (async () => {
+            try {
+                const me = await client.request("/api/me", "GET", undefined, true, { signal: AbortSignal.timeout(3000), stallMs: 3000 });
+                return typeof me?.user?.name === "string" && me.user.name.trim() ? me.user.name.trim() : null;
+            }
+            catch {
+                return null;
+            }
+        })());
+    return signedIn.get(key);
 }
 /** The Method's declared secrets from this computer or the environment, as method run gives them. */
 async function declaredSecrets(file) {
@@ -178,8 +206,10 @@ export async function caseGate(file, accept = [], reason) {
     process.stderr.write(`Cases checked in ${Math.round(t.duration_ms / 1000)} s: ${t.live_model_steps} live model step${t.live_model_steps === 1 ? "" : "s"}, ${t.judge_calls} judge call${t.judge_calls === 1 ? "" : "s"}.\n`);
     const failing = report.cases.filter((c) => !["pass", "fixed"].includes(c.verdict));
     const unaccepted = failing.filter((c) => !accept.includes(c.id));
+    const authors = new Map(cases.map((c) => [c.id, c.author]));
+    const shown = (c) => authors.get(c.id) ? `${caseName({ ...c, author: authors.get(c.id) })} (${c.verdict})` : `${c.id} (${c.verdict}: ${c.note})`;
     if (unaccepted.length)
-        throw Object.assign(Error(`This version breaks ${unaccepted.length} approved case${unaccepted.length === 1 ? "" : "s"}: ${unaccepted.map((c) => `${c.id} (${c.verdict}: ${c.note})`).join("; ")}. Fix the Method and run method test, or retire a case whose rule no longer applies with method case retire. To publish anyway, add --accept-failing-case ${unaccepted.map((c) => c.id).join(",")} with --reason.`), { code: "cases_failed" });
+        throw Object.assign(Error(`This version breaks ${unaccepted.length} approved case${unaccepted.length === 1 ? "" : "s"}: ${unaccepted.map(shown).join("; ")}. Fix the Method and run method test, or retire a case whose rule no longer applies with method case retire. To publish anyway, add --accept-failing-case ${unaccepted.map((c) => c.id).join(",")} with --reason.`), { code: "cases_failed" });
     if (failing.length && !reason)
         throw Error("Give --reason for accepting a failing case.");
     return { report, line: failing.length ? `Cases: ${report.cases.length - failing.length} of ${report.cases.length} passed; accepted failing ${failing.map((c) => c.id).join(", ")}.` : `Cases: ${report.cases.length} of ${report.cases.length} passed.` };
@@ -214,7 +244,7 @@ export async function caseCommand(args) {
     if (privacy)
         process.stderr.write(privacy + "\n");
     print(await createCase({ methodFile, runDir: values.run ? authoringPath(values.run) : undefined, passingRun: values["passing-run"] ? authoringPath(values["passing-run"]) : undefined,
-        id: values.id, note: values.note, author: values.author ?? null, rubric: values.rubric ?? [], ref: values.ref, context: values.context ?? [], expect: json(values.expect) ?? [],
+        id: values.id, note: values.note, author: values.author ?? await signedInName(), rubric: values.rubric ?? [], ref: values.ref, context: values.context ?? [], expect: json(values.expect) ?? [],
         observations: json(values.observations), redact: json(values.redact), runs: integer(values.runs, "--runs"), minPass: integer(values["min-pass"], "--min-pass"),
         retentionDays: integer(values["retention-days"], "--retention-days"), supersedes: values.supersedes ?? [], casesDir, acceptConflict: values["accept-conflict"], config: prepared.config,
         options: { runOptions: { processPath: prepared.processPath, secrets: await declaredSecrets(methodFile), ...(prepared.classification ? { classification: prepared.classification } : {}), ...(prepared.hostedModels ? { hostedModels: prepared.hostedModels } : {}) } } }));

package/dist/packages/sdk/src/run-saved.d.ts

@@ -1,5 +1,9 @@
 import { MethodClient } from './method-client.js';
 import type { parse } from './local-cli.js';
+/** How often a run that waits for the shared state checks again. Tests make it short. */
+export declare const stateWait: {
+    pollMs: number;
+};
 /** A run whose steps all finished: completed, or unconfirmed (an external change could not be confirmed). */
 export declare const finishedRun: (status: string) => status is "unconfirmed" | "completed";
 export declare function runSaved(saved: any, flags: ReturnType<typeof parse>['values'], client: MethodClient): Promise<any>;

package/dist/packages/sdk/src/run-saved.js

@@ -13,6 +13,37 @@ import { workerRunId } from './run-worker.js';
 import { readDocument } from './authoring.js';
 import { withInputsFrom } from './inputs-from.js';
 import { setupFailure } from './failure.js';
+/** How often a run that waits for the shared state checks again. Tests make it short. */
+export const stateWait = { pollMs: 10_000 };
+const clock = (at) => { const date = at ? new Date(at) : undefined; return date && !isNaN(+date) ? `${String(date.getHours()).padStart(2, '0')}:${String(date.getMinutes()).padStart(2, '0')}` : undefined; };
+/**
+ * Take the shared state. While another run that still runs (or lost its connection) holds it, say so once and check
+ * again until it is free: there is no time limit, and method cancel stops the wait. A run that stopped while it held
+ * the state stops this one: a person must check that run's actions before releasing it.
+ */
+async function acquireState(client, statePath, runId, methodId) {
+    let told = false;
+    for (;;) {
+        try {
+            return await client.request(statePath, 'POST', { action: 'acquire', run_id: runId });
+        }
+        catch (error) {
+            const owner = error?.body?.owner;
+            if (error?.code !== 'state_owned')
+                throw error;
+            if (owner && (owner.status === 'finished' || owner.status === 'failed')) {
+                const name = owner.started_by ?? 'Another person';
+                throw Object.assign(Error(`${name}'s run stopped while it held the shared state. ${name} must check its actions, then run \`method state ${methodId} --release ${owner.run_id}\`.`), { code: 'state_held', owner: 'setup' });
+            }
+            if (!told) {
+                const started = clock(owner?.started_at);
+                process.stderr.write(`Waiting for ${owner?.started_by ? `${owner.started_by}'s run` : 'another run'}${started ? ` (started ${started})` : ''} to finish with the shared state${owner?.link ? `: ${owner.link}` : '.'}\n`);
+                told = true;
+            }
+            await new Promise(resolve => setTimeout(resolve, stateWait.pollMs));
+        }
+    }
+}
 // Older versions are listed only after their saved-package tests pass.
 const supportedPackageRuntimes = new Set([runtimeVersion, '0.14.0', '0.12.0', '0.11.1', '0.11.0', '0.10.0', '0.9.5', '0.9.4', '0.9.3', '0.7.0', '0.7.1', '0.7.2', '0.8.0', '0.8.1', '0.8.2', '0.8.3']);
 /** A run whose steps all finished: completed, or unconfirmed (an external change could not be confirmed). */
@@ -48,10 +79,17 @@ export async function runSaved(saved, flags, client) {
             return completed;
         }
     }
-    flags = await withInputsFrom(flags, directory, undefined, client);
     const inputFile = join(directory, 'requested-inputs.json');
-    const inputs = flags.inputs ? JSON.parse(readFileSync(resolve(flags.inputs), 'utf8')) : existsSync(inputFile) ? JSON.parse(readFileSync(inputFile, 'utf8')) : {};
-    writePrivateJson(inputFile, inputs);
+    // The start line already linked to this run: inputs that cannot be read fail it below, after its start is recorded.
+    let inputs = {}, unreadable;
+    try {
+        flags = await withInputsFrom(flags, directory, undefined, client);
+        inputs = flags.inputs ? JSON.parse(readFileSync(resolve(flags.inputs), 'utf8')) : existsSync(inputFile) ? JSON.parse(readFileSync(inputFile, 'utf8')) : {};
+        writePrivateJson(inputFile, inputs);
+    }
+    catch (error) {
+        unreadable = error;
+    }
     const setupFile = join(directory, 'setup.json');
     const setupEvents = existsSync(setupFile) ? JSON.parse(readFileSync(setupFile, 'utf8')) : [];
     setupEvents.push({ at: new Date().toISOString(), type: 'setup_started' });
@@ -61,6 +99,8 @@ export async function runSaved(saved, flags, client) {
     let acquired = false, started = false, revision = 0;
     const statePath = `/api/cli/methods/${encodeURIComponent(saved.workflow_id)}/state`;
     try {
+        if (unreadable)
+            throw unreadable;
         const resuming = !!flags.resume && existsSync(join(directory, 'checkpoint.json'));
         if (resuming)
             assertCheckpointExecutor(JSON.parse(readFileSync(join(directory, 'checkpoint.json'), 'utf8')));
@@ -91,7 +131,7 @@ export async function runSaved(saved, flags, client) {
         if (shared.enabled) {
             if (flags.state)
                 throw Error('This Method uses account state. Do not replace it with --state.');
-            const state = await client.request(statePath, 'POST', { action: 'acquire', run_id: request.run_id });
+            const state = await acquireState(client, statePath, request.run_id, saved.workflow_id);
             acquired = true;
             revision = state.revision;
             const pendingFile = join(directory, 'state-pending.json');
@@ -116,7 +156,7 @@ export async function runSaved(saved, flags, client) {
                 const result = await client.request(statePath, 'POST', commit);
                 revision = result.revision;
             }
-        }, client, config);
+        }, client, config, {}, saved.saved_by ?? null);
         // Every step finished (an unconfirmed run too), so the run no longer owns the shared state.
         if (acquired && finishedRun(result.status)) {
             await client.request(statePath, 'POST', { action: 'release', run_id: request.run_id });

package/dist/packages/sdk/src/versions.js

@@ -6,7 +6,7 @@ import { loadWorkflow, parseDocumentValue, serializeWorkflow } from '../../workf
 import { buildPackage } from './method-files.js';
 import { authoringPath, readDocument } from './authoring.js';
 import { Outbox, lastSaved, savedVersions } from './outbox.js';
-import { claimHome, recordHome, writtenFiles } from './home.js';
+import { claimHome } from './home.js';
 export const methodIdPattern = /^wf_[a-f0-9]{32}$/;
 /** A new account Method ID, made on this computer. The first save of this ID creates the Method. */
 export const newMethodId = () => `wf_${randomBytes(16).toString('hex')}`;
@@ -98,7 +98,6 @@ export async function prepareVersion(client, outbox, file, reason) {
     const { pack, sources, tooLarge } = await buildPackage(file, workflow);
     const versionId = versionIdFor(id, pack.digest);
     const url = `${client.server}/methods/${id}?version=${versionId}`;
-    recordHome(client.server, id, file, { version_id: versionId, files: writtenFiles(file, pack.files) });
     if (savedVersions(client.server)[versionId])
         return { method_id: id, version_id: versionId, url, unchanged: true, workflow };
     const previous = lastSaved(client.server, id);
@@ -107,7 +106,8 @@ export async function prepareVersion(client, outbox, file, reason) {
     for (const f of pack.files)
         outbox.add({ kind: 'file', server: client.server, sha256: f.sha256, size: f.size }, sources[f.sha256]);
     outbox.add({ kind: 'version', server: client.server, method_id: id, version_id: versionId, file: authoringPath(file), body: {
-            workflow, package: pack, ...(previous && previous.version_id !== versionId ? { parent_version_id: previous.version_id } : {}),
+            workflow, package: pack, ...(previous?.version_id && previous.version_id !== versionId ? { parent_version_id: previous.version_id } : {}),
+            ...(previous?.merged_version_id && previous.merged_version_id !== versionId ? { merged_version_id: previous.merged_version_id } : {}),
             reason: reason ?? changeReason(previous?.workflow, workflow),
         } });
     return { method_id: id, version_id: versionId, url, unchanged: false, workflow };
@@ -115,6 +115,8 @@ export async function prepareVersion(client, outbox, file, reason) {
 /** The one line a run prints about its version. */
 export function savedLine(client, outbox, version) {
     const known = savedVersions(client.server)[version.version_id];
+    if (known?.beside !== undefined)
+        return `Saved beside ${known.beside ? `${known.beside}'s` : 'a'} newer version; your next run combines them.`;
     if (known)
         return `Saved as version ${known.version_number}: ${version.url}`;
     const failure = outbox.failure(version.version_id);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@method-ai-hq/sdk",
-  "version": "0.18.1",
+  "version": "0.19.0",
   "description": "Build and run reusable .method files with checked steps and saved results.",
   "license": "MIT",
   "type": "module",
@@ -157,6 +157,11 @@
       "import": "./dist/packages/sdk/src/versions.js",
       "default": "./dist/packages/sdk/src/versions.js"
     },
+    "./merge": {
+      "types": "./dist/packages/sdk/src/merge.d.ts",
+      "import": "./dist/packages/sdk/src/merge.js",
+      "default": "./dist/packages/sdk/src/merge.js"
+    },
     "./outbox": {
       "types": "./dist/packages/sdk/src/outbox.d.ts",
       "import": "./dist/packages/sdk/src/outbox.js",