toolroll 0.9.104 → 0.9.105

package/dist/landed-cleanup.js

@@ -1,28 +1,3 @@
-/**
- * Landed work (reconcile, and `toolroll storage clean --landed` for what piled up before): a finished result whose
- * work is already in main is marked complete by Toolroll, with a ledger entry saying why, and its clean checkout and
- * local build and plan branches go.
- *
- * Landed means, for the exact current result: its pull request merged for that commit, its commit is reachable from
- * main, or every path it changed since it left main has the same committed entry in main (both sides of a rename; a
- * file it deleted is deleted there too). Anything missing or ambiguous, and every git error, is "not proven", and
- * nothing happens. Remotes are never changed, and tags are never touched.
- *
- * Which main: a build shares the project's .git, so it can move the local main or repoint origin. Marking a task
- * complete therefore trusts only what Toolroll recorded (the merged pull request) or the main of the remote the
- * owner's project add recorded, fetched by this process into a private directory (remote-main.ts); the pre-teardown
- * re-check of a teardown that completed its task uses the same proof. A task a person already completed is torn
- * down on the local main's word, as before: nothing is completed by it.
- *
- * Teardown is crash-safe: the completion and the teardown intent (each checkout and branch, with the commit it must
- * still be at) are written in one transaction before anything is removed. Each removal is checked again right before
- * it happens and recorded right after; a crash in between leaves its item pending, the next reconcile finishes it, and
- * a resource already gone finishes its item.
- *
- * Never removed: a checkout with changes (untracked files count), one in use, or one whose HEAD moved past the landed
- * work; a branch Toolroll didn't create (its reflog's first entry says so), a scout's, or one that moved, is checked
- * out anywhere, or that an unfinished task uses.
- */
 import { existsSync, realpathSync } from "node:fs";
 import { basename } from "node:path";
 import { assignmentOf, owedAcceptance } from "./assignment.js";
@@ -33,23 +8,17 @@ import { COMPLETION_ACTION, LANDED_ACTOR, familyChangedFiles } from "./result-co
 import { refusal, teardownGit } from "./teardown-git.js";
 import { SCOUT_PREFIX, branchCreatedMessage } from "./worktree.js";
 const DAY_MS = 86_400_000;
-/** `storage clean --landed` takes only what has waited at least this long. */
 export const BACKLOG_DAYS = 7;
-/** The local branches the one-time pass looks at: Toolroll's build and plan branches, under either name. */
 export const BACKLOG_PREFIXES = ["toolroll/", "toolroll-plan/", "standing-orders/"];
-/** The ledger action that closes a teardown. */
 export const LANDED_CLEANED_ACTION = "landed work cleaned up";
-/** Reconcile looks at most this many results and finishes at most this many items a pass; the pass by hand has no cap. */
 export const AUTO_LOOKS = 20;
 export const AUTO_ITEMS = 40;
 const MAIN = "refs/heads/main";
 const SHA = /^[0-9a-f]{40}$/;
-/** Landed cleanup's git, reads and teardown alike: always the hardened teardown helper (teardown-git.ts). */
 export function gitOf(runner) {
     return teardownGit(runner);
 }
 const notProven = (why) => ({ landed: false, why });
-/** The commit a ref names, null when it doesn't exist, or "error" when git couldn't say. */
 async function commitOf(git, repo, ref) {
     const found = await git(repo, ["rev-parse", "--verify", "--quiet", `${ref}^{commit}`]);
     if (found.code === 1 && found.stdout.trim() === "")
@@ -57,14 +26,12 @@ async function commitOf(git, repo, ref) {
     const oid = found.stdout.trim();
     return found.code === 0 && SHA.test(oid) ? oid : "error";
 }
-/** Whether `older` is `newer` or one of its ancestors; null when git couldn't say. */
 async function within(git, repo, older, newer) {
     if (older === newer)
         return true;
     const asked = await git(repo, ["merge-base", "--is-ancestor", older, newer]);
     return asked.code === 0 ? true : asked.code === 1 ? false : null;
 }
-/** Every committed entry of a commit's tree, path → "mode oid"; null on a git error. */
 async function treeOf(git, repo, commit) {
     const listed = await git(repo, ["ls-tree", "-r", "-z", "--full-tree", commit]);
     if (listed.code !== 0)
@@ -81,7 +48,6 @@ async function treeOf(git, repo, commit) {
     }
     return entries;
 }
-/** Whether `head`'s work is in `main`, both read where `git` runs. */
 async function workIn(git, repo, head, main, trusted) {
     const reachable = await within(git, repo, head, main);
     if (reachable === null)
@@ -92,7 +58,6 @@ async function workIn(git, repo, head, main, trusted) {
     const base = forked.stdout.trim();
     if (forked.code !== 0 || !SHA.test(base))
         return notProven(forked.code === 1 ? "it shares no history with main" : "git couldn't compare it with main");
-    // Every path it changed since it left main, both sides of a rename (no rename detection: a rename is a delete and an add).
     const changed = await git(repo, ["diff-tree", "-r", "-z", "--name-only", "--no-renames", "--no-commit-id", base, head]);
     if (changed.code !== 0)
         return notProven("git couldn't list its changes");
@@ -110,11 +75,6 @@ async function workIn(git, repo, head, main, trusted) {
 const mergedProof = (head, pullRequest) => pullRequest !== null && pullRequest.merged && pullRequest.headSha === head
     ? { landed: true, how: "merged", reason: pullRequest.number === null ? "its pull request merged" : `pull request #${pullRequest.number} merged`, trusted: true }
     : null;
-/**
- * Whether this commit's work landed, read from what Toolroll recorded and the local repository. Fails closed: every
- * doubt is "not proven", with the reason in a few words. Only a recorded merge is trusted to complete a task: a build
- * can write the local main.
- */
 export async function landedProof(git, repo, head, pullRequest = null) {
     if (head === null || !SHA.test(head))
         return notProven("it has no saved commit");
@@ -131,11 +91,6 @@ export async function landedProof(git, repo, head, pullRequest = null) {
         return notProven("its commit isn't in the repository");
     return workIn(git, repo, head, main, false);
 }
-/**
- * The proof automatic completion trusts: a recorded merge of this exact commit, or its work in the main of the
- * project's recorded remote, compared only in the private directory that main was fetched into. `remote` is read only
- * when no recorded merge settles it.
- */
 export async function remoteLandedProof(remote, repo, head, pullRequest = null) {
     if (head === null || !SHA.test(head))
         return notProven("it has no saved commit");
@@ -149,7 +104,6 @@ export async function remoteLandedProof(remote, repo, head, pullRequest = null)
         return notProven("its commit couldn't be compared with the remote main");
     return workIn((_cwd, args) => read.remote.git(args), "", head, read.remote.main, true);
 }
-/** Every local branch: name → commit. */
 async function localBranches(git, repo) {
     const listed = await git(repo, ["for-each-ref", "--format=%(refname)%00%(objectname)", "refs/heads/"]);
     if (listed.code !== 0)
@@ -163,11 +117,6 @@ async function localBranches(git, repo) {
     }
     return out;
 }
-/**
- * When Toolroll created a branch (ms), read from its reflog's first entry, which Toolroll writes naming the branch
- * (worktree.ts). Its last commit's date says nothing about that. A scout's branch, and a branch whose first entry is
- * anything else (made by hand, copied, renamed, or its reflog expired), is not Toolroll's to remove: why, instead.
- */
 async function branchBirth(git, repo, name) {
     if (name.startsWith(SCOUT_PREFIX))
         return { why: "it is a scout's branch" };
@@ -176,14 +125,12 @@ async function branchBirth(git, repo, name) {
     const at = /@\{(\d+)\}$/.exec(selector);
     return log.code === 0 && at !== null && message === branchCreatedMessage(name) ? { at: Number(at[1]) * 1000 } : { why: "Toolroll has no record of creating it" };
 }
-/** A path as the file system names it (git reports /private/var for /var on macOS). */
 const real = (path) => { try {
     return realpathSync(path);
 }
 catch {
     return path;
 } };
-/** The branch each working tree of the repository has checked out: branch → path. */
 async function checkedOut(git, repo) {
     const listed = await git(repo, ["worktree", "list", "--porcelain"]);
     if (listed.code !== 0)
@@ -198,7 +145,6 @@ async function checkedOut(git, repo) {
     }
     return out;
 }
-/** Only the exact build and plan names owned by this family's versions. A run can record any branch. */
 function familyBranches(versions) {
     const names = new Set();
     for (const version of versions) {
@@ -207,8 +153,6 @@ function familyBranches(versions) {
     }
     return names;
 }
-/** Finished results in a project whose family is settled on them (the current version, done), newest first, that no
- * teardown has taken yet. */
 function settledResults(store, repo) {
     return store.handle.prepare(`SELECT r.external_id AS id, r.id AS ref, res.id AS run, res.head_revision AS head, res.finished_at AS finished_at,
       EXISTS (SELECT 1 FROM action_ledger a WHERE a.run_id = res.id AND a.action = ? AND a.source = 'work') AS completed
@@ -230,15 +174,12 @@ function pullRequestOf(store, runId) {
     const merged = publication.state === "opened" && (publication.remoteState === "MERGED" || (follow?.["merged_at"] ?? null) !== null);
     return { merged, headSha: publication.headSha, number: publication.prNumber };
 }
-/** A base commit is not work this run landed, even if it is already in main. */
 function resultProblem(store, runId, head) {
     const run = store.getRun(runId);
     if (run === null || run.role !== "builder" || run.finishedAt === null || head === null || run.headRevision !== head)
         return "its result couldn't be read";
     return run.outcome === "no-change" || run.baseRevision === head ? "its result has no new work" : null;
 }
-/** Use the current manual completion guards. Only a recorded merge of this exact result can settle them. Also why a
- * youiyoux options task a person decided on in the hub stays for review (youiyoux-intake.ts). */
 export function completionProblem(store, assignment, root) {
     if (assignment.state !== "ready-to-check" && assignment.state !== "complete")
         return "it needs a decision first";
@@ -255,15 +196,8 @@ export function completionProblem(store, assignment, root) {
         return "a person still needs to accept its result";
     return store.protectedResultProblem(receipt.taskId, familyChangedFiles(store, receipt.taskId, receipt.runId, root), null);
 }
-/** Why a result proven only by the local main stays for a person: a build can write that main. */
 const UNTRUSTED = "its work isn't in the project's recorded remote main";
-/** Results Reconcile found not landed, by what they were read against: read again only once something changed. */
 const notLanded = new Map();
-/**
- * Results in a project whose work landed, with what their teardown would remove and what stays. Reads only.
- * `limit` caps how many results are read against git (reconcile's bound; results read before and unchanged since
- * don't count); `before` takes only results finished before it (the one-time pass's seven days).
- */
 export async function landedResults(store, git, remotes, repo, root, now, options = {}) {
     const found = [], kept = [];
     if (!existsSync(repo))
@@ -272,7 +206,6 @@ export async function landedResults(store, git, remotes, repo, root, now, option
     if (branches === null || inUse === null)
         return { found, kept: [{ repo, what: repo, why: "git couldn't read the project" }] };
     const worktrees = store.listWorktrees().filter(row => row.repo === repo);
-    // The recorded remote's main, fetched once for this look and only when a result needs it.
     let remoteRead = null;
     const remote = () => remoteRead ??= remotes.read(repo);
     let looked = 0;
@@ -292,12 +225,10 @@ export async function landedResults(store, git, remotes, repo, root, now, option
         const names = familyBranches(family.versions);
         const checkouts = worktrees.filter(one => names.has(one.branch));
         const present = [...names].filter(name => branches.has(name));
-        // Complete and nothing left to remove: nothing to do.
         if (row.completed && present.length === 0 && checkouts.length === 0)
             continue;
         const pullRequest = pullRequestOf(store, row.run);
         const merged = pullRequest?.merged === true && pullRequest.headSha === row.head;
-        // A result to complete is read against the recorded remote's main; one a person completed, the local main.
         const read = row.completed || merged ? null : await remote();
         const against = read === null ? `local:${main}` : read.ok ? `remote:${read.remote.url}\u0000${read.remote.main}` : `none:${read.why}`;
         const key = `${repo}\u0000${row.run}`;
@@ -354,12 +285,6 @@ export async function landedResults(store, git, remotes, repo, root, now, option
     }
     return { found, kept };
 }
-// ---- the intent ------------------------------------------------------------
-/**
- * Mark a landed result complete (unless it already is) and record its teardown, in one transaction, bound to the
- * exact result read: refused when the result changed since. The completion's ledger entry says why. Returns the
- * teardown's id; a result already taken returns its existing teardown.
- */
 export function recordLandedIntent(store, candidate, now, root, actor = LANDED_ACTOR) {
     return store.transact(() => {
         const existing = store.handle.prepare("SELECT id FROM landed_cleanup WHERE run_id = ?").get(candidate.runId);
@@ -391,17 +316,11 @@ export function recordLandedIntent(store, candidate, now, root, actor = LANDED_A
         return { ok: true, id, completed: completes };
     });
 }
-/**
- * A teardown's items (in its intent's transaction). One pending item per target: an earlier teardown's pending item
- * for the same target is handed over, since this intent was read later; the earlier one keeps a record saying so and
- * finishes once nothing else of it is pending. A teardown with nothing to remove finishes at once.
- */
 function addItems(store, cleanup, repo, targets, at) {
     const pending = store.handle.prepare("SELECT id, cleanup FROM landed_cleanup_item WHERE kind = ? AND repo = ? AND target = ? AND state = 'pending'");
     const handOver = store.handle.prepare("UPDATE landed_cleanup_item SET state = 'kept', why = ?, done_at = ? WHERE id = ?");
     const insert = store.handle.prepare("INSERT INTO landed_cleanup_item (cleanup, kind, repo, target, expect) VALUES (?, ?, ?, ?, ?)");
     const earlier = new Set();
-    // Checkouts first: a branch goes only once nothing has it checked out.
     for (const one of [...targets].sort((a, b) => (a.kind === "checkout" ? 0 : 1) - (b.kind === "checkout" ? 0 : 1))) {
         const held = pending.get(one.kind, repo, one.target);
         if (held !== undefined && Number(held["cleanup"]) === cleanup)
@@ -415,7 +334,6 @@ function addItems(store, cleanup, repo, targets, at) {
     for (const one of [...earlier, cleanup])
         settle(store, one, at);
 }
-/** A teardown with nothing pending is finished: one ledger entry says what it did. Within a transaction. */
 function settle(store, cleanup, at) {
     const left = store.handle.prepare("SELECT state, COUNT(*) AS n FROM landed_cleanup_item WHERE cleanup = ? GROUP BY state").all(cleanup);
     const count = (state) => Number(left.find(row => row["state"] === state)?.["n"] ?? 0);
@@ -438,10 +356,7 @@ export function recordBranchIntent(store, branch, now, actor) {
         return id;
     });
 }
-/** Every name prefix a task's own build or plan branch may have. */
 const TASK_PREFIXES = ["toolroll/", "standing-orders/", "toolroll-plan/", "standing-orders-plan/"];
-/** Who uses a branch, and how: what any task's runs recorded on it, or the task its name belongs to (a plan
- * branch is named after its task too). The strongest reason to keep it wins; undefined when no task names it. */
 function branchUser(store, statuses, name) {
     let found = statuses.byBranch.get(name);
     for (const prefix of TASK_PREFIXES) {
@@ -454,7 +369,6 @@ function branchUser(store, statuses, name) {
     }
     return found;
 }
-/** Validate persisted targets too: an older intent may name an arbitrary run branch. */
 function allowedBranch(store, item, name) {
     if (name === "main" || name === "master" || name.startsWith(SCOUT_PREFIX))
         return false;
@@ -463,7 +377,6 @@ function allowedBranch(store, item, name) {
     const family = store.taskFamilyOf(item.taskId, null, true);
     return item.runId !== null && family !== null && family.current.repo === item.repo && familyBranches(family.versions).has(name);
 }
-/** Same local default as the builder protects: origin HEAD, then the parent checkout's branch. */
 async function isDefaultBranch(git, repo, name) {
     if (name === "main" || name === "master")
         return true;
@@ -478,7 +391,6 @@ async function isDefaultBranch(git, repo, name) {
     const ref = parent.stdout.trim();
     return parent.code === 0 && ref.startsWith("refs/heads/") ? name === ref.slice("refs/heads/".length) : null;
 }
-/** Whether a teardown's result is still its task's current result; null for a branch no task names. */
 function stillCurrent(store, item) {
     if (item.taskId === null || item.runId === null)
         return item.taskId === null && item.runId === null;
@@ -488,8 +400,6 @@ function stillCurrent(store, item) {
     const latest = store.handle.prepare("SELECT MAX(id) AS id FROM run WHERE task_ref = ? AND finished_at IS NOT NULL AND role IN ('builder','scout')").get(family.current.refId);
     return family.current.state === "done" && Number(latest?.["id"]) === item.runId;
 }
-/** An intent is not a lasting landing proof: main and the recorded PR fact can both change. A teardown that completed
- * its task fetches the recorded remote's main again, right now. */
 async function landingProblem(store, git, remotes, item) {
     if (!stillCurrent(store, item))
         return "its task has newer work";
@@ -503,7 +413,6 @@ async function landingProblem(store, git, remotes, item) {
         : await landedProof(git, item.repo, item.head, pullRequest);
     if (!proof.landed)
         return proof.why;
-    // A family's older branch can carry commits beyond this result that were in main at preview time.
     const inside = await within(git, item.repo, item.expect, item.head);
     if (inside === null)
         return "git couldn't compare its commits";
@@ -514,7 +423,6 @@ async function landingProblem(store, git, remotes, item) {
     }
     return null;
 }
-/** Read immediately before ref deletion, after all asynchronous Git reads. A lease may precede its run or checkout. */
 function branchUseProblem(store, item, now) {
     if (!stillCurrent(store, item))
         return "its task has newer work";
@@ -535,12 +443,6 @@ function branchUseProblem(store, item, now) {
     const status = branchUser(store, taskStatuses(store, now), item.target);
     return status !== undefined && status.keep !== null ? `${status.taskId} uses it (${whyWords({ why: status.keep })})` : null;
 }
-/**
- * Finish what teardowns intended: pending items, oldest first (checkouts before branches). Each is checked again
- * right before it goes, and recorded right after. Doubt leaves it pending for the next pass; a branch that moved, or
- * a result that has newer work, is kept for good. `limit` caps the items settled (removed, already gone or kept), so
- * items left waiting never crowd out later ones. `only` limits it to these teardowns.
- */
 export async function finishLanded(store, pool, git, remotes, now, options = {}) {
     const items = store.handle.prepare(`SELECT i.id, i.cleanup, i.kind, i.repo, i.target, i.expect, c.task_id, c.run_id, c.head, c.reason, c.actor, c.completed
       FROM landed_cleanup_item i JOIN landed_cleanup c ON c.id = i.cleanup
@@ -572,7 +474,6 @@ export async function finishLanded(store, pool, git, remotes, now, options = {})
             step("kept", "its task has newer work");
             continue;
         }
-        // A project whose config could run a command during teardown waits, saying why, with nothing removed.
         const refused = existsSync(item.repo) ? refusal(await git(item.repo, ["rev-parse", "--git-dir"])) : null;
         if (refused !== null) {
             step("waits", refused);
@@ -631,7 +532,6 @@ async function removeCheckout(store, pool, git, remotes, item, now) {
     const actual = await git(row.path, ["symbolic-ref", "--quiet", "HEAD"]);
     if (actual.code !== 0 || actual.stdout.trim() !== `refs/heads/${row.branch}`)
         return { outcome: "waits", why: "its checked-out branch changed" };
-    // Its HEAD must still be the landed work (or behind it): anything newer didn't land.
     const head = await commitOf(git, row.path, "HEAD");
     if (head === null || head === "error")
         return { outcome: "waits", why: "git couldn't read it" };
@@ -644,7 +544,6 @@ async function removeCheckout(store, pool, git, remotes, item, now) {
     const wanted = async (fresh, again) => {
         if (!again)
             return true;
-        // Prune calls this after inspecting the checkout, immediately before removal.
         landingHold = await landingProblem(store, git, remotes, item);
         const current = store.getWorktree(fresh.path);
         return landingHold === null && current !== null && current.repo === item.repo && current.branch === fresh.branch
@@ -671,7 +570,6 @@ async function deleteBranch(store, git, remotes, item, now) {
         return { outcome: "waits", why: "git couldn't read it" };
     if (tip !== item.expect)
         return { outcome: "kept", why: "it moved since" };
-    // Persisted intents are checked too: one recorded before Toolroll proved its branches may name any branch.
     const birth = await branchBirth(git, item.repo, item.target);
     if ("why" in birth)
         return { outcome: "kept", why: birth.why };
@@ -696,17 +594,11 @@ async function deleteBranch(store, git, remotes, item, now) {
     const use = branchUseProblem(store, item, now());
     if (use !== null)
         return { outcome: "waits", why: use };
-    // Deleted only while it still names the expected commit: git checks that and the deletion in one step.
     const gone = await git(item.repo, ["update-ref", "--no-deref", "-d", ref, item.expect]);
     if (gone.code === 0)
         return { outcome: "removed", why: null };
     return (await commitOf(git, item.repo, ref)) === null ? { outcome: "already gone", why: null } : { outcome: "waits", why: "git refused" };
 }
-// ---- reconcile -------------------------------------------------------------
-/**
- * Reconcile's part: finish teardowns a crash cut short, then find newly landed results (a bounded few), mark them
- * complete and tear them down.
- */
 export async function reconcileLanded(store, pool, git, remotes, repo, root, now) {
     const steps = await finishLanded(store, pool, git, remotes, now, { repo, limit: AUTO_ITEMS });
     const { found } = await landedResults(store, git, remotes, repo, root, now(), { limit: AUTO_LOOKS, memo: true });
@@ -724,7 +616,6 @@ export async function reconcileLanded(store, pool, git, remotes, repo, root, now
         steps.push(...await finishLanded(store, pool, git, remotes, now, { repo, limit: AUTO_ITEMS, only: fresh }));
     return { completed, steps };
 }
-/** What landed-work teardowns did so far, and what they still wait on (Settings → Storage). Reads only. */
 export function landedSummary(store) {
     const count = (sql) => Number(store.handle.prepare(sql).get()?.["n"] ?? 0);
     return {
@@ -735,11 +626,6 @@ export function landedSummary(store) {
             .map(row => ({ target: String(row["target"]), why: row["why"] === null ? null : String(row["why"]) })),
     };
 }
-/**
- * What `storage clean --landed` would do now, across every project: landed results finished at least a week ago,
- * and branches Toolroll created (toolroll/, toolroll-plan/, standing-orders/) at least a week ago that no task uses
- * and that landed in main. Reads only.
- */
 export async function landedBacklog(store, git, remotes, root, now, options = {}) {
     const cutoff = new Date(now.getTime() - BACKLOG_DAYS * DAY_MS).toISOString();
     const plan = { at: now.toISOString(), cutoff, results: [], branches: [], kept: [], pending: 0 };
@@ -751,7 +637,6 @@ export async function landedBacklog(store, git, remotes, root, now, options = {}
         plan.results.push(...results.found);
         plan.kept.push(...results.kept, ...results.found.flatMap(one => one.keeps));
         const taken = new Set([...results.found.flatMap(one => [...one.targets.map(target => target.target), ...one.keeps.map(keep => keep.what)])]);
-        // A result that stays already says why: its branches don't say it again.
         const staying = new Set(results.kept.map(one => one.what));
         const [branches, out] = await Promise.all([localBranches(git, repo), checkedOut(git, repo)]);
         if (branches === null || out === null) {
@@ -784,7 +669,6 @@ export async function landedBacklog(store, git, remotes, root, now, options = {}
                 plan.kept.push({ repo, what: name, why: `it is checked out at ${elsewhere}` });
                 continue;
             }
-            // No task names it, so nothing is completed: its teardown reads the local main, as before.
             const proof = await landedProof(git, repo, tip.oid);
             if (!proof.landed) {
                 plan.kept.push({ repo, what: name, why: proof.why });
@@ -795,8 +679,6 @@ export async function landedBacklog(store, git, remotes, root, now, options = {}
     }
     return plan;
 }
-/** Act on a preview: record every teardown first, then carry them out. Refuses nothing it previewed silently: what
- * changed since is reported as kept. */
 export async function cleanLandedBacklog(store, pool, git, remotes, root, now, plan, actor) {
     const ids = new Set();
     const completed = [];
@@ -813,7 +695,6 @@ export async function cleanLandedBacklog(store, pool, git, remotes, root, now, p
     }
     for (const one of plan.branches)
         ids.add(recordBranchIntent(store, one, now(), actor));
-    // Earlier teardowns a crash cut short finish too.
     const earlier = store.handle.prepare("SELECT DISTINCT cleanup FROM landed_cleanup_item WHERE state = 'pending'").all().map(row => Number(row["cleanup"]));
     for (const id of earlier)
         ids.add(id);