@lanes-sh/link 0.5.4 → 0.6.1

package/src/cli/commands/profile/removal.ts

@@ -82,8 +82,17 @@ export interface RemovalPlan {
 }
 
 export interface PlanOptions {
-  /** Restrict to one target. The profile itself then survives. */
-  readonly target?: string | undefined;
+  /**
+   * The target whose stores this plans against.
+   *
+   * Required now, and not a restriction: a profile lives in exactly one target
+   * (ADR-052), so there is no "all of them" left for this to mean. It used to be
+   * optional because a profile could declare several and removing it meant
+   * emptying each.
+   */
+  readonly target: string;
+  /** That target's adapter set, from the workspace declaring it (ADR-052). */
+  readonly declared: TargetConfig;
   readonly openSecrets: (target: string) => Promise<SecretStore>;
   readonly openBlobs: (target: string, area?: string) => Promise<BlobStore>;
   readonly readDefaultProfile?: (() => Promise<string | undefined>) | undefined;
@@ -110,14 +119,13 @@ export async function removalPlan(
   const untouched: { target: string; refs: string[] }[] = [];
   const warnings: string[] = [];
 
-  const names = options.target ? [options.target] : Object.keys(config.targets);
+  // One target, always. A profile lived in as many as it declared and this
+  // planned across all of them; it lives in exactly one now (ADR-052), and that
+  // one is whichever workspace the caller resolved to reach this file.
+  const names: string[] = [options.target];
+  const declared = options.declared;
 
   for (const name of names) {
-    const declared = config.targets[name];
-    if (!declared) {
-      warnings.push(`Target "${name}" is not declared by this profile, so nothing was planned.`);
-      continue;
-    }
 
     // A repository this profile keeps memory and skills in is not this
     // command's to empty, and it is not reachable from here either: the routing
@@ -128,9 +136,9 @@ export async function removalPlan(
     // `rm -r data/<profile>` used to be the whole of "what could this profile
     // reach". So it is said before the operator confirms rather than discovered
     // afterwards.
-    if (declared.knowledge) {
+    if (config.knowledge) {
       warnings.push(
-        `Target "${name}" keeps this profile's memory and skills in ${declared.knowledge.repo}. ` +
+        `This profile keeps its memory and skills in ${config.knowledge.repo}. ` +
           'Nothing here touches a repository, so they survive this removal — delete them there ' +
           'if you want them gone.',
       );
@@ -226,23 +234,26 @@ export async function removalPlan(
     }
   }
 
-  // Only when the whole profile is going. With `--target` it still exists.
-  if (!options.target) {
-    const defaultProfile = await options.readDefaultProfile?.();
-    if (defaultProfile === profile) {
-      items.push({
-        target: null,
-        kind: 'workspace-key',
-        id: 'default_profile',
-        note: 'cleared, not repointed at whatever remains',
-      });
-    }
-
-    // Last. It is the only record of where everything else lives, so a failure
-    // before this point leaves data a later run can still find.
-    items.push({ target: null, kind: 'config', id: profilePath(root, profile) });
+  // Always, now. `--target` used to mean "decommission this one target and leave
+  // the profile behind", which was a coherent thing to want while a profile
+  // could be declared against several. It lives in exactly one (ADR-052), and
+  // the file itself is *in* that target's workspace — so emptying the target and
+  // keeping the profile would leave a config nothing can open, in a workspace it
+  // no longer belongs to.
+  const defaultProfile = await options.readDefaultProfile?.();
+  if (defaultProfile === profile) {
+    items.push({
+      target: null,
+      kind: 'workspace-key',
+      id: 'default_profile',
+      note: 'cleared, not repointed at whatever remains',
+    });
   }
 
+  // Last. It is the only record of where everything else lives, so a failure
+  // before this point leaves data a later run can still find.
+  items.push({ target: null, kind: 'config', id: profilePath(root, profile) });
+
   return { profile, items, untouched, warnings };
 }
 

package/src/cli/commands/profile/remove.ts

@@ -3,6 +3,7 @@ import type { BlobStore } from '#stores/blobs';
 import {
   ConfigError,
   WORKSPACE_FILE,
+  openTarget,
   readWorkspace,
   readWorkspaceFile,
   workspaceFiles,
@@ -250,15 +251,17 @@ export interface RemoveFlags extends GlobalFlags {
  * in the tool.
  */
 export async function removeProfile(name: string, flags: RemoveFlags): Promise<void> {
-  const { selection, config } = await resolveProfileOnly({ ...flags, profile: name });
+  const { selection, config, target } = await resolveProfileOnly({ ...flags, profile: name });
   announceProfile(selection);
 
   const root = selection.workspaceRoot;
   const registry = await buildRegistryWithWorkspace(root, name);
   const files = workspaceFiles(root);
+  const { declared } = await openTarget(root, target);
 
   const plan = await removalPlan(config, root, name, registry, {
-    target: flags.target,
+    target,
+    declared,
     openSecrets: (target) => openSecretStoreFor(config, root, target),
     openBlobs: (target, area) => openBlobStoreFor(config, root, target, area),
     readDefaultProfile: async () => (await readWorkspace(root))?.default_profile,

package/src/cli/commands/profile.ts

@@ -7,10 +7,13 @@ import {
   listProfiles,
   profilePath,
   readWorkspace,
+  isRemoteWorkspace,
+  workspaceFiles,
+  writeWorkspaceFile,
+  resolveTargetWorkspace,
   resolveWorkspaceRoot,
 } from '#profile';
 import { newProfileTemplate, newWorkspaceTemplate } from '../config-edit.ts';
-import { askTarget, localBlock, siblingTarget } from './profile/declare.ts';
 import { emit, ok, print, style, table } from '../output.ts';
 
 /**
@@ -48,70 +51,80 @@ export interface ProfileListing {
 /**
  * Write a new profile, and the workspace file if this is the first one.
  *
- * The targets are the argument that used to be missing. `--target` was accepted
+ * The target is the argument that used to be missing. `--target` was accepted
  * and dropped here, and the template could only ever emit `local` — so the
  * command reported success and produced a profile that could not reach the
  * deployment the operator had just told it about.
+ *
+ * It now decides *where the file goes* rather than what is written in it: a
+ * profile lives in one target's workspace and declares nothing about it
+ * (ADR-052), so `--target cloud` writes into the bucket and the endpoint there
+ * serves it on its next reconcile.
  */
 export async function createProfile(
   name: string,
   options: { targets: readonly string[]; nonInteractive?: boolean },
 ): Promise<ProfileCreated> {
-  const root = resolveWorkspaceRoot();
+  const local = resolveWorkspaceRoot();
+  const target = options.targets[0]!;
+
+  // The workspace file before the target is resolved, not after. `profile add
+  // <name> --target local` on an empty directory is how a workspace comes into
+  // existence, and the target it names is declared *by* that file — so writing
+  // it second means resolving a target nothing has declared yet.
+  if (!isRemoteWorkspace(local) && !existsSync(join(local, WORKSPACE_FILE))) {
+    await mkdir(local, { recursive: true });
+    await writeFile(join(local, WORKSPACE_FILE), newWorkspaceTemplate(), { mode: 0o600 });
+  }
+
+  const root = await resolveTargetWorkspace(local, target);
   const path = profilePath(root, name);
 
-  if (existsSync(path)) throw new Error(`Profile "${name}" already exists at ${path}`);
+  if (await workspaceFiles(root).has(`profiles/${name}.yaml`)) {
+    throw new Error(`Profile "${name}" already exists at ${path}`);
+  }
 
-  await mkdir(join(root, 'profiles'), { recursive: true });
+  // Only a directory needs making. A bucket has no directories, and the write
+  // that follows creates the key outright.
+  if (!isRemoteWorkspace(root)) await mkdir(join(root, 'profiles'), { recursive: true });
 
   // Each profile gets its own port so two can serve at once without an
   // operator having to think about it.
   const existing = await listProfiles(root);
   const port = FIRST_PORT + existing.length;
 
-  // Everything that can fail — a target nobody declares, a prompt nobody can
-  // answer — happens before the first write, so a refusal leaves the workspace
-  // exactly as it was rather than half a profile behind.
-  const blocks: string[] = [];
-  const copiedFrom: Record<string, string> = {};
-
-  for (const target of options.targets) {
-    if (target === 'local') {
-      blocks.push(localBlock(name));
-      continue;
-    }
-
-    const declared = await askTarget({
-      target,
-      profile: name,
-      sibling: await siblingTarget(root, target, name),
-      ...(options.nonInteractive === true ? { nonInteractive: true } : {}),
-    });
-
-    blocks.push(declared.block);
-    if (declared.from) copiedFrom[target] = declared.from;
-  }
-
-  const workspaceFile = join(root, WORKSPACE_FILE);
-  if (!existsSync(workspaceFile)) {
-    await writeFile(workspaceFile, newWorkspaceTemplate(), { mode: 0o600 });
-  }
-
-  await writeFile(path, newProfileTemplate(name, port, blocks.join('')), { mode: 0o600 });
+  // The prompting that used to happen here is gone. A new profile had to be
+  // given an adapter block per target it declared, and for anything but `local`
+  // there was nothing safe to derive one from — so the command copied a
+  // sibling's, or asked. It declares no target now (ADR-052): it is written into
+  // the workspace of the target it was named with, and that workspace already
+  // says where its bytes go.
+  await writeWorkspaceFile(
+    workspaceFiles(root),
+    `profiles/${name}.yaml`,
+    newProfileTemplate(name, port),
+  );
 
-  return { name, path, port, targets: options.targets, copiedFrom };
+  return { name, path, port, targets: options.targets, copiedFrom: {} };
 }
 
 /**
- * Every profile in the workspace, and which one is the default.
+ * Every profile in one target's workspace, and which one is the default.
+ *
+ * **It takes a target, and that is the whole point of ADR-052.** A profile lives
+ * in exactly one target's workspace, so "which profiles exist" is a question
+ * about a target rather than about this machine — `personal` on `local` and
+ * `personal` on `cloud` are two files in two places, and listing the local
+ * directory for both is precisely the confusion this change removes.
  *
  * Names and paths only — deliberately not each profile's port, which would mean
  * parsing every config. One unparseable profile would then fail the command
  * that tells you which profiles exist, and that is exactly when you need it.
  * `status --json` reports the endpoint for a profile you have named.
  */
-export async function readProfiles(): Promise<ProfileListing> {
-  const root = resolveWorkspaceRoot();
+export async function readProfiles(target: string): Promise<ProfileListing> {
+  const local = resolveWorkspaceRoot();
+  const root = await resolveTargetWorkspace(local, target);
   const profiles = await listProfiles(root);
   const workspace = await readWorkspace(root);
 
@@ -158,8 +171,11 @@ export async function profileAdd(
   });
 }
 
-export async function profileList(options: { json?: boolean } = {}): Promise<void> {
-  const listing = await readProfiles();
+export async function profileList(
+  target: string,
+  options: { json?: boolean } = {},
+): Promise<void> {
+  const listing = await readProfiles(target);
 
   return emit(options.json, listing, () => {
     if (listing.profiles.length === 0) {

package/src/cli/commands/sync.ts

@@ -1,42 +1,35 @@
-import {
-  ConfigError,
-  findDeployment,
-  loadWorkspaceProfiles,
-  recordDeployment,
-  resolveWorkspaceRoot,
-} from '#profile';
-import {
-  applyBlobs,
-  applyPulls,
-  applyPushes,
-  planBlobs,
-  planProfile,
-  profilesInEither,
-  resolved,
-  type Prefer,
-  type ProfileSync,
-} from '#deployments/sync-apply.ts';
-import { conflictsIn, type Change } from '#deployments/sync.ts';
-import { deployedWorkspace } from '#deployments/upload.ts';
+import { ConfigError, readRegistry, recordTarget, resolveWorkspaceRoot } from '#profile';
 import { discoverDeployments, holdsWorkspace } from '#deployments/discover.ts';
-import { emit, heading, ok, print, style, waiting, warn } from '../output.ts';
+import { emit, heading, ok, print, style, waiting } from '../output.ts';
 import { confirm, isInteractive } from '../prompt.ts';
 import type { GlobalFlags } from '../runtime.ts';
 
 /**
- * `lanes link sync targets` — the workspace and a target's copy of it, reconciled.
+ * `lanes link sync targets` — adopt a deployment this workspace has lost track of.
  *
- * A deploy leaves two copies of every profile: the one in the workspace and the
- * one in the bucket the endpoint reads. They are meant to agree, and when they
- * stop there was no way to find out, let alone to say which side had lost
- * something. The reported case: a local profile was rewritten and lost its
- * cloud target, `auth.authorization`, and six connections, while the bucket
- * still held every one of them and the service went on answering.
+ * **This used to reconcile two copies of every profile, and there is only one
+ * now.** A deploy left the workspace holding one copy and the bucket another,
+ * they were meant to agree, and when they stopped there was no way to say which
+ * side had lost something. The reported case, twice: a local profile was
+ * rewritten and lost its cloud target, `auth.authorization`, and six
+ * connections, while the bucket still held every one of them and the service
+ * went on answering.
  *
- * Union, and refuse where a union is impossible (ADR-044). Nothing here
- * overwrites a value that exists on both sides — that is `--prefer`, asked for
- * explicitly, because silently choosing one copy over the other is the failure
- * this command was written in response to.
+ * ADR-052 removed the second copy rather than the disagreement. A profile lives
+ * in exactly one target's workspace, so the diff engine this command was built
+ * around — `sync-apply.ts`, `sync.ts`, `--prefer local|remote` — had nothing
+ * left to compare and is gone with contract 1.
+ *
+ * What survives is the half that was never about merging: **finding a
+ * deployment the local registry has no pointer to**, and writing that pointer.
+ * A new machine, a reinstall, a workspace file restored from something older —
+ * the endpoint is still serving, and what went missing is the line saying where
+ * it lives. That is one write, and it cannot lose anything, because the bucket
+ * is authoritative for everything except its own address.
+ *
+ * `--prefer` is gone and is refused by name rather than ignored: it decided
+ * which side won a merge, and someone typing it is asking for behaviour this
+ * command no longer has.
  */
 
 export interface SyncFlags extends GlobalFlags {
@@ -47,22 +40,13 @@ export interface SyncFlags extends GlobalFlags {
   readonly prefer?: string | undefined;
 }
 
-function parsePrefer(value: string | undefined): Prefer | undefined {
-  if (value === undefined) return undefined;
-  if (value !== 'local' && value !== 'remote') {
-    throw new ConfigError(`--prefer must be "local" or "remote", not "${value}"`);
-  }
-  return value;
-}
-
 /**
- * Where the target's copy lives, tried cheapest first.
+ * Where the target's workspace is, tried cheapest first.
  *
- * The order is the point. A declared target answers instantly and is right
- * whenever anything is; the index answers instantly and is right when the
- * declaration is what went missing; `--from` is for when the operator knows and
- * the workspace does not; and discovery is the one that works from nothing, at
- * the cost of a `gcloud` call per project.
+ * The order is the point. An existing pointer answers instantly and is right
+ * whenever anything is; `--from` is for when the operator knows and the
+ * workspace does not; and discovery is the one that works from nothing, at the
+ * cost of a `gcloud` call per project.
  */
 async function locateRemote(
   root: string,
@@ -72,26 +56,20 @@ async function locateRemote(
   if (flags.from) {
     if (!(await holdsWorkspace(flags.from))) {
       throw new ConfigError(
-        `${flags.from} does not hold a workspace — no ${'lanes-link.yaml'} in it.\n` +
+        `${flags.from} does not hold a workspace — no lanes-link.yaml in it.\n` +
           '  Check the bucket name, or run with --discover to search for one.',
       );
     }
     return { workspace: flags.from.replace(/\/$/, ''), how: '--from' };
   }
 
-  for (const entry of (await loadWorkspaceProfiles(root)).loaded) {
-    const declared = entry.config.targets[target];
-    const workspace = declared ? deployedWorkspace(declared) : undefined;
-    if (workspace) return { workspace, how: `declared by ${entry.profile}` };
-  }
-
-  const recorded = await findDeployment(root, target);
-  if (recorded) return { workspace: recorded.workspace, how: 'recorded by a previous deploy' };
+  const entry = (await readRegistry(root))[target];
+  if (entry?.workspace) return { workspace: entry.workspace, how: 'already recorded' };
 
   if (flags.discover !== true) {
     throw new ConfigError(
       `Nothing here says where "${target}" lives.\n` +
-        '  No profile declares it, and no deploy recorded it in lanes-link.yaml.\n\n' +
+        '  No pointer to it in lanes-link.yaml, and nothing else records one.\n\n' +
         '  If you know the bucket:  lanes link sync targets --target ' +
         `${target} --from gs://<bucket>\n` +
         `  If you do not:           lanes link sync targets --target ${target} --discover`,
@@ -99,9 +77,7 @@ async function locateRemote(
   }
 
   const candidates = (
-    await waiting('searching your projects for a deployment', () =>
-      discoverDeployments(),
-    )
+    await waiting('searching your projects for a deployment', () => discoverDeployments())
   ).filter((candidate) => candidate.workspace !== undefined);
 
   if (candidates.length === 0) {
@@ -117,8 +93,8 @@ async function locateRemote(
     print(style.dim(`    workspace ${candidate.workspace}`));
   }
 
-  // One is offered rather than chosen: adopting the wrong deployment would
-  // merge a stranger's config into this workspace.
+  // One is offered rather than chosen: adopting the wrong deployment would point
+  // this workspace at a stranger's accounts.
   const first = candidates[0]!;
   if (candidates.length > 1 || !isInteractive()) {
     throw new ConfigError(
@@ -127,136 +103,92 @@ async function locateRemote(
     );
   }
 
-  if (!(await confirm(`  Sync "${target}" against ${first.workspace}?`))) {
+  if (!(await confirm(`  Point "${target}" at ${first.workspace}?`))) {
     throw new ConfigError('Nothing was read or written.');
   }
 
   return { workspace: first.workspace!, how: 'discovered' };
 }
 
-const arrow = (direction: Change['direction']): string =>
-  direction === 'pull' ? style.green('←') : direction === 'push' ? style.cyan('→') : style.yellow('!');
-
-const describe = (change: Change): string => {
-  const path = change.path.length === 0 ? 'the whole profile' : change.path.join('.');
-  if (change.direction === 'pull') return `${path}  ${style.dim('missing locally')}`;
-  if (change.direction === 'push') return `${path}  ${style.dim('missing remotely')}`;
-  return `${path}  ${style.dim(`local ${short(change.local)} ≠ remote ${short(change.remote)}`)}`;
-};
-
-const short = (value: unknown): string => {
-  const text = typeof value === 'string' ? value : JSON.stringify(value);
-  return (text ?? 'nothing').length > 40 ? `${(text ?? '').slice(0, 37)}…` : (text ?? 'nothing');
-};
-
 export async function syncTargets(flags: SyncFlags): Promise<void> {
   const target = flags.target!;
-  const prefer = parsePrefer(flags.prefer);
   const root = resolveWorkspaceRoot();
 
-  const { workspace: remote, how } = await locateRemote(root, target, flags);
+  if (flags.prefer !== undefined) {
+    throw new ConfigError(
+      '--prefer decided which of two copies of a profile won a merge, and there is\n' +
+        'only one copy now: the one in the target\'s own workspace (ADR-052).\n' +
+        '  This command adopts a deployment, and adopting cannot overwrite anything.\n' +
+        '  Drop the flag and run it again.',
+    );
+  }
 
-  const names = flags.profile ? [flags.profile] : await profilesInEither(root, remote);
-  const plans: ProfileSync[] = [];
-  for (const profile of names) plans.push(await planProfile(root, remote, profile, prefer));
+  const { workspace, how } = await locateRemote(root, target, flags);
 
-  const blobs = await planBlobs(root, remote);
-  const conflicts = [
-    ...plans.flatMap((plan) => conflictsIn(plan.changes)),
-    ...blobs.filter((blob) => blob.direction === 'conflict'),
-  ];
+  // What is actually there, so an adoption cannot point at an empty bucket and
+  // report success. This is the one read the command makes, and it is also the
+  // check: a workspace that declares this target is a workspace that can serve
+  // it.
+  const remoteRegistry = await readRegistry(workspace);
+  const declaresIt = remoteRegistry[target] !== undefined;
+  const existing = (await readRegistry(root))[target];
+  const already = existing?.workspace === workspace;
 
-  const payload = {
-    workspace: root,
-    remote,
-    target,
-    profiles: plans.map((plan) => ({ profile: plan.profile, changes: plan.changes })),
-    blobs,
-    conflicts: conflicts.length,
-    applied: false,
-  };
+  const payload = { workspace: root, remote: workspace, target, how, declaresIt, applied: false };
 
   const render = (): void => {
     print(style.dim(`workspace ${style.bold(root)}  target ${style.bold(target)}`));
-    print(style.dim(`remote    ${remote}  (${how})`));
-
-    let anything = false;
-    for (const plan of plans) {
-      if (plan.changes.length === 0) continue;
-      anything = true;
+    print(style.dim(`remote    ${workspace}  (${how})`));
+    print('');
 
-      heading(plan.profile);
-      for (const change of plan.changes) print(`  ${arrow(change.direction)} ${describe(change)}`);
+    if (!declaresIt) {
+      const there = Object.keys(remoteRegistry).sort().join(', ') || 'none';
+      print(
+        style.yellow(
+          `${workspace} does not declare a target called "${target}" (it declares: ${there}).`,
+        ),
+      );
+      print(
+        style.dim(
+          '  Adopting it would write a pointer to a workspace that cannot answer for\n' +
+            '  this target. Check the name, or deploy it there first.',
+        ),
+      );
+      return;
     }
 
-    if (blobs.length > 0) {
-      anything = true;
-      heading('Skills and manifests');
-      for (const blob of blobs) print(`  ${arrow(blob.direction)} ${blob.key}`);
+    if (already) {
+      print(ok('already pointed there — nothing to change'));
+      return;
     }
 
-    if (!anything) print(ok('already in step — nothing to copy in either direction'));
+    heading('Would write');
+    print(`  targets.${target}.workspace: ${workspace}`);
+    print(style.dim('  The bucket keeps everything else; this records where it is.'));
   };
 
-  if (conflicts.length > 0 && prefer === undefined) {
+  if (!declaresIt) {
     render();
-    print('');
-    throw new ConfigError(
-      `${conflicts.length} conflict(s): both copies hold these, and they disagree.\n` +
-        '  Nothing was written. Re-run with --prefer local or --prefer remote,\n' +
-        '  or edit one side so they agree.',
-    );
-  }
-
-  if (flags.dryRun === true) {
-    return emit(flags.json, payload, () => {
-      render();
-      print('');
-      print(style.dim('  --dry-run: nothing was written on either side.'));
-    });
+    throw new ConfigError(`"${target}" is not declared at ${workspace}.`);
   }
 
-  if (flags.json !== true) render();
-
-  let pulled = 0;
-  let pushed = 0;
-  for (const plan of plans) {
-    const changes = resolved(plan.changes, prefer);
-    pulled += await applyPulls(root, remote, plan.profile, changes);
-    if (await applyPushes(root, remote, plan.profile, changes)) pushed += 1;
+  if (flags.dryRun || already) {
+    render();
+    if (flags.dryRun) print(style.dim('  --dry-run: nothing was written.'));
+    return emit(flags.json, payload, () => {});
   }
 
-  const copied = await applyBlobs(
-    root,
-    remote,
-    resolvedBlobs(blobs, prefer),
-  );
+  render();
 
-  // Recorded now that a bucket has been confirmed to hold this target's
-  // workspace: the next recovery does not have to discover it again.
-  await recordDeployment(root, { target, workspace: remote });
-
-  return emit(flags.json, { ...payload, applied: true, pulled, pushed, copied }, () => {
-    print('');
-    if (pulled === 0 && pushed === 0 && copied === 0) return;
+  // Only the pointer. Everything that describes the target — its adapters, its
+  // deploy block, whose token opens it — is declared where it lives, and reading
+  // it from there is what makes this safe to run on a workspace that has lost
+  // its own copy of anything.
+  await recordTarget(root, target, { workspace });
 
-    print(ok(`${pulled} key(s) pulled, ${pushed} profile(s) pushed, ${copied} file(s) copied`));
-    print(style.dim(`  recorded ${remote} in lanes-link.yaml, so this is findable next time`));
-    if (pushed > 0) {
-      print(style.dim(`  the endpoint re-reads its config on the next call — or run:`));
-      print(style.dim(`    lanes link status --target ${target}`));
-    }
-  });
-}
+  print('');
+  print(ok(`"${target}" now points at ${workspace}`));
+  print(style.dim(`  lanes link status --target ${target}   reads it from there`));
 
-/** A conflicting file follows `--prefer` like a conflicting key does. */
-function resolvedBlobs(
-  blobs: readonly { key: string; direction: 'pull' | 'push' | 'conflict' }[],
-  prefer: Prefer | undefined,
-): { key: string; direction: 'pull' | 'push' }[] {
-  return blobs.flatMap((blob) => {
-    if (blob.direction !== 'conflict') return [{ key: blob.key, direction: blob.direction }];
-    if (prefer === undefined) return [];
-    return [{ key: blob.key, direction: prefer === 'remote' ? ('pull' as const) : ('push' as const) }];
-  });
+  return emit(flags.json, { ...payload, applied: true }, () => {});
 }