e670d18
@@ -400,13 +400,14 @@
function freeSlots(app: App, repo: Repo, now: Date): number {
}
/** The pickable issues in slot order: the owner's raised on top, then the roadmap, small last and none past their share (#7571). */
function inSlotOrder(app: App, repo: Repo, ready: readonly Ranked[], slotted: readonly Run[], slots: number): Ranked[] {
function inSlotOrder(app: App, repo: Repo, ready: readonly Ranked[], slotted: readonly Run[], slots: number, picked: ReadonlySet<string> = new Set()): Ranked[] {
  const issues = ready.map((r) => r.issue);
  const small = smallIssues(app.db, issues);
  const roadmap = roadmapIssues(app.db, repo, issues.map((i) => i.id));
  const first = firstAt(app.db, issues.map((i) => i.id));
  const raised = raisedAt(app.db, issues.map((i) => i.id));
  const running = smallOfIds(app.db, slotted.flatMap((r) => (r.issueId === null ? [] : [r.issueId])));
  // Issues picked earlier in this tick hold their share before their runs show (#8729).
  const running = smallOfIds(app.db, [...new Set([...slotted.flatMap((r) => (r.issueId === null ? [] : [r.issueId])), ...picked])]);
  return slotOrder(
    ready,
    (r) => ({
@@ -443,6 +444,27 @@
export async function driveRepo(
  app: App,
  repo: Repo,
  now = new Date(),
): Promise<Drove> {
  // One start per free builder slot (#8729). Each pass re-reads the ceiling,
  // the paced slots and the held filters, so a start the dispatcher refused
  // or a spend that reached the wall ends the tick's starts there.
  // An issue picked this tick may not have its run yet: it is kept out of the
  // next pass and counted against the slots until the run shows.
  const taken = new Set<string>();
  const did = await driveOnce(app, repo, now, taken);
  if (did !== "picked") return did;
  for (let n = 1; n < Math.max(1, repo.autonomySlots); n++) {
    const next = await driveOnce(app, getRepoById(app.db, repo.id) ?? repo, now, taken);
    if (next !== "picked") break;
  }
  return did;
}
async function driveOnce(
  app: App,
  repo: Repo,
  now: Date,
  taken: Set<string>,
): Promise<Drove> {
  if (repo.autonomy === "off") return "off";
  const status = autonomyStatus(app, repo, now);
@@ -452,6 +474,9 @@
export async function driveRepo(
  const crew = listCrewRoles(app.db, repo.id);
  const active = activeRuns(app, repo.id);
  const slotted = slottedRuns(active, crew);
  // Picked earlier in this tick and not yet running: still a slot spent.
  const running = new Set(active.map((r) => r.issueId));
  const pending = [...taken].filter((id) => !running.has(id)).length;
  // Slots follow the subscriptions' remaining windows, never past the
  // operator's; at a wall nothing new starts until the reset.
  const paced = repoPace(app, repo, now);
@@ -478,10 +503,11 @@
export async function driveRepo(
    ),
    held.relieving,
  );
  const ready = held.startable;
  if (slotted.length < paced.slots && releaseForPace(app, repo, by, slotted.length, ready.length, now) !== undefined)
  const ready = held.startable.filter((r) => !taken.has(r.issue.id));
  const used = slotted.length + pending;
  if (used < paced.slots && releaseForPace(app, repo, by, used, ready.length, now) !== undefined)
    return "released";
  if (slotted.length >= paced.slots) {
  if (used >= paced.slots) {
    // The builders are busy; the planner can still refill the map, when
    // the reserve is short — counted, never assumed: a full crew with a
    // full reserve is not a reason to plan (#1097, #3237).
@@ -508,8 +534,9 @@
export async function driveRepo(
    )
  );
  // The roadmap first, and small issues held to their share of the slots (#7571).
  const next = await nextOf(app, repo, inSlotOrder(app, repo, pickable, slotted, paced.slots));
  const next = await nextOf(app, repo, inSlotOrder(app, repo, pickable, slotted, paced.slots, taken));
  if (next !== undefined) {
    taken.add(next.issue.id);
    const routed = await routeIssue(app, repo, next.issue, crewFor(next.issue), inFlight);
    if (!routed) return "paused";
    const builder = routed.builder;
@@ -225,6 +225,46 @@
describe("the tick says why each ready issue cannot start", () => {
    expect(heldWords(held)).toBe("open_pull=1");
  });
  test("one tick starts a run per free slot, and a held issue never takes one (#8729)", async () => {
    const { repo: made, mason } = await crewed(app, alice, "slots");
    for (const name of ["mason2", "mason3"]) {
      const created = await createAgent(app, alice, { username: name });
      if (!created.ok) throw new Error(String(created.error));
      expect(addToCrew(app, alice, getRepoById(app.db, made.id)!, name).ok).toBe(true);
    }
    const set = await updateRepoSettings(app, alice, getRepoById(app.db, made.id)!, { autonomySlots: 3 });
    if (!set.ok) throw new Error(JSON.stringify(set.error));
    const repo = getRepoById(app.db, made.id)!;
    const seeded = await commitToBranch(app, alice, repo, {
      message: "Start",
      files: [{ path: "README.md", content: "# slots\n" }],
    });
    if (!seeded.ok) throw new Error(JSON.stringify(seeded.error));
    const held = issue(repo, "Alpha rounding of corners");
    const rest = [
      issue(repo, "Bravo caching of thumbnails"),
      issue(repo, "Charlie escaping of titles"),
      issue(repo, "Delta printing of receipts"),
    ];
    // The first has a pull opened a moment ago, so the dispatcher would refuse it.
    const headBranch = `mason/${held.number}-alpha`;
    const branch = await commitToBranch(app, alice, repo, {
      branch: headBranch,
      base: "main",
      message: "Alpha",
      files: [{ path: "alpha.ts", content: "export const n = 1;\n" }],
    });
    if (!branch.ok) throw new Error(JSON.stringify(branch.error));
    const pull = await openPull(app, mason, repo, { title: "Alpha", body: "Done.", baseBranch: "main", headBranch });
    if (!pull.ok) throw new Error(String(pull.error));
    expect(await driveRepo(app, getRepoById(app.db, repo.id)!)).toBe("picked");
    // Assigning is the event that starts a run: exactly the three startable issues are assigned.
    const taken = [held, ...rest].filter((i) => getIssueById(app.db, i.id)!.assigneeId !== null).map((i) => i.id);
    expect(taken.sort()).toEqual(rest.map((i) => i.id).sort());
    expect(heldWords(heldNow(app, getRepoById(app.db, repo.id)!))).toContain("open_pull=1");
  });
  test("a sentinel finding is a builder's to start on the next tick, never parked on the sentinel (#3002)", async () => {
    const { repo, mason } = await crewed(app, alice, "watched");
    const fresh = () => getRepoById(app.db, repo.id)!;
@@ -89,13 +89,13 @@
function open(title: string): Issue {
  return made.value;
}
/** Drives once; a pick gets the run its assignment would start, so it holds a slot. */
async function drive(issues: readonly Issue[]): Promise<Issue | undefined> {
/** Drives once; a tick starts one issue per free slot, and each pick gets the run its assignment would start. */
async function drive(issues: readonly Issue[]): Promise<Issue[]> {
  const before = new Set(issues.filter((i) => getIssueById(app.db, i.id)!.assigneeId !== null).map((i) => i.id));
  if ((await driveRepo(app, fresh())) !== "picked") return undefined;
  const picked = issues.map((i) => getIssueById(app.db, i.id)!).find((i) => i.assigneeId !== null && !before.has(i.id));
  if (picked === undefined) return undefined;
  createRun(app.db, { repoId: repo.id, kind: "agent", issueId: picked.id, actorId: picked.assigneeId ?? undefined, reason: "assigned" });
  if ((await driveRepo(app, fresh())) !== "picked") return [];
  const picked = issues.map((i) => getIssueById(app.db, i.id)!).filter((i) => i.assigneeId !== null && !before.has(i.id));
  for (const i of picked)
    createRun(app.db, { repoId: repo.id, kind: "agent", issueId: i.id, actorId: i.assigneeId ?? undefined, reason: "assigned" });
  return picked;
}
@@ -156,8 +156,7 @@
test("with 5 slots and only small issues ready, at most 2 start; then an epic's
  const small = ["A test pins the title", "A test pins the body", "A test pins the date", "A test pins the tags"].map(open);
  const started: Issue[] = [];
  for (let n = 0; n < 5; n++) {
    const picked = await drive(small);
    if (picked !== undefined) started.push(picked);
    started.push(...(await drive(small)));
  }
  expect(started.length).toBe(2);
  expect(smallShareWords(app, fresh())).toBe("2/2");
@@ -168,18 +167,18 @@
test("with 5 slots and only small issues ready, at most 2 start; then an epic's
  expect(linkIssue(app, alice, fresh(), epic, child).ok).toBe(true);
  app.db.query("UPDATE run SET state = 'ok' WHERE issue_id = ?1").run(started[0]!.id);
  const next = await drive([...small, child]);
  expect(next?.id).toBe(child.id);
  expect(next.map((i) => i.id)).toContain(child.id);
});
test("one small issue of two slots shows on /board's Today, the studio's crew panel and the terminal's Flow", async () => {
  expect(smallShareWords(app, fresh())).toBe("1/2");
  expect(smallShareWords(app, fresh())).toBe("2/2");
  const board = await (await get("/board")).text();
  const today = board.slice(board.indexOf('id="today"'));
  expect(today).toContain("small issues: 1 of 2 slots");
  expect(today).toContain("small issues: 2 of 2 slots");
  const studio = await (await get("/alice/notes/settings")).text();
  expect(studio).toMatch(/<dt>Small issues<\/dt>\s*<dd>1\/2 slots<\/dd>/);
  expect(studio).toMatch(/<dt>Small issues<\/dt>\s*<dd>2\/2 slots<\/dd>/);
  const flow = heldLines(readHeld(app, true), 200).join("\n");
  expect(flow).toMatch(/^alice\/notes startable=\d+.* small 1\/2$/m);
  expect(flow).toMatch(/^alice\/notes startable=\d+.* small 2\/2$/m);
});
test("what the owner raised again starts before an epic's issue", async () => {
@@ -188,21 +187,23 @@
test("what the owner raised again starts before an epic's issue", async () => {
  const child = open("Export notes as text");
  expect(linkIssue(app, alice, fresh(), epic, child).ok).toBe(true);
  app.db.query("INSERT INTO issue_raise (issue_id, raised_at) VALUES (?1, ?2)").run(plain.id, new Date().toISOString());
  expect((await drive([plain, child]))?.id).toBe(plain.id);
  expect((await drive([plain, child]))?.id).toBe(child.id);
  // Both start in the one tick: slots are free for the owner's issue and the epic's.
  expect((await drive([plain, child])).map((i) => i.id).sort()).toEqual([plain.id, child.id].sort());
});
test("slots.smallShare set on /settings/capacity changes the pick: 0 starts no small issue, 100 does; out of range is refused", async () => {
  // The earlier ticks filled the slots; those runs end so this pick has room.
  app.db.query("UPDATE run SET state = 'ok' WHERE repo_id = ?1 AND state IN ('queued','running')").run(repo.id);
  const small = open("A test pins the colour");
  expect((await setShare("0")).status).toBe(303);
  expect(smallShare(app.db)).toBe(0);
  expect(await drive(opened)).toBeUndefined();
  expect(await drive(opened)).toEqual([]);
  expect(getIssueById(app.db, small.id)!.assigneeId).toBeNull();
  expect((await setShare("100")).status).toBe(303);
  expect(smallShare(app.db)).toBe(100);
  const picked = await drive(opened);
  expect(picked).toBeDefined();
  expect(isSmall(picked!.title, [])).toBe(true);
  expect(picked.length).toBeGreaterThan(0);
  for (const i of picked) expect(isSmall(i.title, [])).toBe(true);
  for (const value of ["101", "-1", "half"]) {
    await setShare(value);
    expect(smallShare(app.db)).toBe(100);
		@@ -400,13 +400,14 @@ function freeSlots(app: App, repo: Repo, now: Date): number {
400	400	}
401	401
402	402	/** The pickable issues in slot order: the owner's raised on top, then the roadmap, small last and none past their share (#7571). */
403		function inSlotOrder(app: App, repo: Repo, ready: readonly Ranked[], slotted: readonly Run[], slots: number): Ranked[] {
	403	function inSlotOrder(app: App, repo: Repo, ready: readonly Ranked[], slotted: readonly Run[], slots: number, picked: ReadonlySet<string> = new Set()): Ranked[] {
404	404	const issues = ready.map((r) => r.issue);
405	405	const small = smallIssues(app.db, issues);
406	406	const roadmap = roadmapIssues(app.db, repo, issues.map((i) => i.id));
407	407	const first = firstAt(app.db, issues.map((i) => i.id));
408	408	const raised = raisedAt(app.db, issues.map((i) => i.id));
409		const running = smallOfIds(app.db, slotted.flatMap((r) => (r.issueId === null ? [] : [r.issueId])));
	409	// Issues picked earlier in this tick hold their share before their runs show (#8729).
	410	const running = smallOfIds(app.db, [...new Set([...slotted.flatMap((r) => (r.issueId === null ? [] : [r.issueId])), ...picked])]);
410	411	return slotOrder(
411	412	ready,
412	413	(r) => ({
		@@ -443,6 +444,27 @@ export async function driveRepo(
443	444	app: App,
444	445	repo: Repo,
445	446	now = new Date(),
	447	): Promise<Drove> {
	448	// One start per free builder slot (#8729). Each pass re-reads the ceiling,
	449	// the paced slots and the held filters, so a start the dispatcher refused
	450	// or a spend that reached the wall ends the tick's starts there.
	451	// An issue picked this tick may not have its run yet: it is kept out of the
	452	// next pass and counted against the slots until the run shows.
	453	const taken = new Set<string>();
	454	const did = await driveOnce(app, repo, now, taken);
	455	if (did !== "picked") return did;
	456	for (let n = 1; n < Math.max(1, repo.autonomySlots); n++) {
	457	const next = await driveOnce(app, getRepoById(app.db, repo.id) ?? repo, now, taken);
	458	if (next !== "picked") break;
	459	}
	460	return did;
	461	}
	462
	463	async function driveOnce(
	464	app: App,
	465	repo: Repo,
	466	now: Date,
	467	taken: Set<string>,
446	468	): Promise<Drove> {
447	469	if (repo.autonomy === "off") return "off";
448	470	const status = autonomyStatus(app, repo, now);
		@@ -452,6 +474,9 @@ export async function driveRepo(
452	474	const crew = listCrewRoles(app.db, repo.id);
453	475	const active = activeRuns(app, repo.id);
454	476	const slotted = slottedRuns(active, crew);
	477	// Picked earlier in this tick and not yet running: still a slot spent.
	478	const running = new Set(active.map((r) => r.issueId));
	479	const pending = [...taken].filter((id) => !running.has(id)).length;
455	480	// Slots follow the subscriptions' remaining windows, never past the
456	481	// operator's; at a wall nothing new starts until the reset.
457	482	const paced = repoPace(app, repo, now);
		@@ -478,10 +503,11 @@ export async function driveRepo(
478	503	),
479	504	held.relieving,
480	505	);
481		const ready = held.startable;
482		if (slotted.length < paced.slots && releaseForPace(app, repo, by, slotted.length, ready.length, now) !== undefined)
	506	const ready = held.startable.filter((r) => !taken.has(r.issue.id));
	507	const used = slotted.length + pending;
	508	if (used < paced.slots && releaseForPace(app, repo, by, used, ready.length, now) !== undefined)
483	509	return "released";
484		if (slotted.length >= paced.slots) {
	510	if (used >= paced.slots) {
485	511	// The builders are busy; the planner can still refill the map, when
486	512	// the reserve is short — counted, never assumed: a full crew with a
487	513	// full reserve is not a reason to plan (#1097, #3237).
		@@ -508,8 +534,9 @@ export async function driveRepo(
508	534	)
509	535	);
510	536	// The roadmap first, and small issues held to their share of the slots (#7571).
511		const next = await nextOf(app, repo, inSlotOrder(app, repo, pickable, slotted, paced.slots));
	537	const next = await nextOf(app, repo, inSlotOrder(app, repo, pickable, slotted, paced.slots, taken));
512	538	if (next !== undefined) {
	539	taken.add(next.issue.id);
513	540	const routed = await routeIssue(app, repo, next.issue, crewFor(next.issue), inFlight);
514	541	if (!routed) return "paused";
515	542	const builder = routed.builder;
		@@ -225,6 +225,46 @@ describe("the tick says why each ready issue cannot start", () => {
225	225	expect(heldWords(held)).toBe("open_pull=1");
226	226	});
227	227
	228	test("one tick starts a run per free slot, and a held issue never takes one (#8729)", async () => {
	229	const { repo: made, mason } = await crewed(app, alice, "slots");
	230	for (const name of ["mason2", "mason3"]) {
	231	const created = await createAgent(app, alice, { username: name });
	232	if (!created.ok) throw new Error(String(created.error));
	233	expect(addToCrew(app, alice, getRepoById(app.db, made.id)!, name).ok).toBe(true);
	234	}
	235	const set = await updateRepoSettings(app, alice, getRepoById(app.db, made.id)!, { autonomySlots: 3 });
	236	if (!set.ok) throw new Error(JSON.stringify(set.error));
	237	const repo = getRepoById(app.db, made.id)!;
	238	const seeded = await commitToBranch(app, alice, repo, {
	239	message: "Start",
	240	files: [{ path: "README.md", content: "# slots\n" }],
	241	});
	242	if (!seeded.ok) throw new Error(JSON.stringify(seeded.error));
	243	const held = issue(repo, "Alpha rounding of corners");
	244	const rest = [
	245	issue(repo, "Bravo caching of thumbnails"),
	246	issue(repo, "Charlie escaping of titles"),
	247	issue(repo, "Delta printing of receipts"),
	248	];
	249	// The first has a pull opened a moment ago, so the dispatcher would refuse it.
	250	const headBranch = `mason/${held.number}-alpha`;
	251	const branch = await commitToBranch(app, alice, repo, {
	252	branch: headBranch,
	253	base: "main",
	254	message: "Alpha",
	255	files: [{ path: "alpha.ts", content: "export const n = 1;\n" }],
	256	});
	257	if (!branch.ok) throw new Error(JSON.stringify(branch.error));
	258	const pull = await openPull(app, mason, repo, { title: "Alpha", body: "Done.", baseBranch: "main", headBranch });
	259	if (!pull.ok) throw new Error(String(pull.error));
	260
	261	expect(await driveRepo(app, getRepoById(app.db, repo.id)!)).toBe("picked");
	262	// Assigning is the event that starts a run: exactly the three startable issues are assigned.
	263	const taken = [held, ...rest].filter((i) => getIssueById(app.db, i.id)!.assigneeId !== null).map((i) => i.id);
	264	expect(taken.sort()).toEqual(rest.map((i) => i.id).sort());
	265	expect(heldWords(heldNow(app, getRepoById(app.db, repo.id)!))).toContain("open_pull=1");
	266	});
	267
228	268	test("a sentinel finding is a builder's to start on the next tick, never parked on the sentinel (#3002)", async () => {
229	269	const { repo, mason } = await crewed(app, alice, "watched");
230	270	const fresh = () => getRepoById(app.db, repo.id)!;
		@@ -89,13 +89,13 @@ function open(title: string): Issue {
89	89	return made.value;
90	90	}
91	91
92		/** Drives once; a pick gets the run its assignment would start, so it holds a slot. */
93		async function drive(issues: readonly Issue[]): Promise<Issue \| undefined> {
	92	/** Drives once; a tick starts one issue per free slot, and each pick gets the run its assignment would start. */
	93	async function drive(issues: readonly Issue[]): Promise<Issue[]> {
94	94	const before = new Set(issues.filter((i) => getIssueById(app.db, i.id)!.assigneeId !== null).map((i) => i.id));
95		if ((await driveRepo(app, fresh())) !== "picked") return undefined;
96		const picked = issues.map((i) => getIssueById(app.db, i.id)!).find((i) => i.assigneeId !== null && !before.has(i.id));
97		if (picked === undefined) return undefined;
98		createRun(app.db, { repoId: repo.id, kind: "agent", issueId: picked.id, actorId: picked.assigneeId ?? undefined, reason: "assigned" });
	95	if ((await driveRepo(app, fresh())) !== "picked") return [];
	96	const picked = issues.map((i) => getIssueById(app.db, i.id)!).filter((i) => i.assigneeId !== null && !before.has(i.id));
	97	for (const i of picked)
	98	createRun(app.db, { repoId: repo.id, kind: "agent", issueId: i.id, actorId: i.assigneeId ?? undefined, reason: "assigned" });
99	99	return picked;
100	100	}
101	101
		@@ -156,8 +156,7 @@ test("with 5 slots and only small issues ready, at most 2 start; then an epic's
156	156	const small = ["A test pins the title", "A test pins the body", "A test pins the date", "A test pins the tags"].map(open);
157	157	const started: Issue[] = [];
158	158	for (let n = 0; n < 5; n++) {
159		const picked = await drive(small);
160		if (picked !== undefined) started.push(picked);
	159	started.push(...(await drive(small)));
161	160	}
162	161	expect(started.length).toBe(2);
163	162	expect(smallShareWords(app, fresh())).toBe("2/2");
		@@ -168,18 +167,18 @@ test("with 5 slots and only small issues ready, at most 2 start; then an epic's
168	167	expect(linkIssue(app, alice, fresh(), epic, child).ok).toBe(true);
169	168	app.db.query("UPDATE run SET state = 'ok' WHERE issue_id = ?1").run(started[0]!.id);
170	169	const next = await drive([...small, child]);
171		expect(next?.id).toBe(child.id);
	170	expect(next.map((i) => i.id)).toContain(child.id);
172	171	});
173	172
174	173	test("one small issue of two slots shows on /board's Today, the studio's crew panel and the terminal's Flow", async () => {
175		expect(smallShareWords(app, fresh())).toBe("1/2");
	174	expect(smallShareWords(app, fresh())).toBe("2/2");
176	175	const board = await (await get("/board")).text();
177	176	const today = board.slice(board.indexOf('id="today"'));
178		expect(today).toContain("small issues: 1 of 2 slots");
	177	expect(today).toContain("small issues: 2 of 2 slots");
179	178	const studio = await (await get("/alice/notes/settings")).text();
180		expect(studio).toMatch(/<dt>Small issues<\/dt>\s*<dd>1\/2 slots<\/dd>/);
	179	expect(studio).toMatch(/<dt>Small issues<\/dt>\s*<dd>2\/2 slots<\/dd>/);
181	180	const flow = heldLines(readHeld(app, true), 200).join("\n");
182		expect(flow).toMatch(/^alice\/notes startable=\d+.* small 1\/2$/m);
	181	expect(flow).toMatch(/^alice\/notes startable=\d+.* small 2\/2$/m);
183	182	});
184	183
185	184	test("what the owner raised again starts before an epic's issue", async () => {
		@@ -188,21 +187,23 @@ test("what the owner raised again starts before an epic's issue", async () => {
188	187	const child = open("Export notes as text");
189	188	expect(linkIssue(app, alice, fresh(), epic, child).ok).toBe(true);
190	189	app.db.query("INSERT INTO issue_raise (issue_id, raised_at) VALUES (?1, ?2)").run(plain.id, new Date().toISOString());
191		expect((await drive([plain, child]))?.id).toBe(plain.id);
192		expect((await drive([plain, child]))?.id).toBe(child.id);
	190	// Both start in the one tick: slots are free for the owner's issue and the epic's.
	191	expect((await drive([plain, child])).map((i) => i.id).sort()).toEqual([plain.id, child.id].sort());
193	192	});
194	193
195	194	test("slots.smallShare set on /settings/capacity changes the pick: 0 starts no small issue, 100 does; out of range is refused", async () => {
	195	// The earlier ticks filled the slots; those runs end so this pick has room.
	196	app.db.query("UPDATE run SET state = 'ok' WHERE repo_id = ?1 AND state IN ('queued','running')").run(repo.id);
196	197	const small = open("A test pins the colour");
197	198	expect((await setShare("0")).status).toBe(303);
198	199	expect(smallShare(app.db)).toBe(0);
199		expect(await drive(opened)).toBeUndefined();
	200	expect(await drive(opened)).toEqual([]);
200	201	expect(getIssueById(app.db, small.id)!.assigneeId).toBeNull();
201	202	expect((await setShare("100")).status).toBe(303);
202	203	expect(smallShare(app.db)).toBe(100);
203	204	const picked = await drive(opened);
204		expect(picked).toBeDefined();
205		expect(isSmall(picked!.title, [])).toBe(true);
	205	expect(picked.length).toBeGreaterThan(0);
	206	for (const i of picked) expect(isSmall(i.title, [])).toBe(true);
206	207	for (const value of ["101", "-1", "half"]) {
207	208	await setShare(value);
208	209	expect(smallShare(app.db)).toBe(100);