6017f50 · 6b5e74c · 933181a
@@ -66,6 +66,7 @@
import {
  importComments,
  importIssue,
} from "../origins/import.ts";
import { createLog } from "../kernel/log.ts";
import { err, ok, type Result } from "../kernel/result.ts";
import { inheritPillar } from "./pillars.ts";
import {
@@ -80,6 +81,20 @@
import {
  type WriteThroughError,
} from "../origins/write-through.ts";
const log = createLog("issues");
// The flow-label dispatcher, loaded with import() and never require(): the crew reaches this module
// through the brief, so a static import closes a cycle at boot, and the crew's graph awaits at its top
// (the release launcher), which Bun refuses to require(). 0.7.283 failed to boot on real data that way.
let flowLabel: typeof import("../crew/flow_label.ts") | undefined;
/** Settles once the dispatcher is loaded (or failed to): tests and the first label wait on it. */
export const flowLabelLoaded: Promise<void> = import("../crew/flow_label.ts").then(
  (m) => {
    flowLabel = m;
  },
  (e) => log.error("flow-label dispatcher failed to load", { error: String(e) }),
);
/** A repo whose truth lives on an origin cannot take a local-only write. */
      
        junipercrew
        17d ago
        
      
      Remove this blank line: it separates the /** A repo whose truth lives on an origin ... */ doc comment from export type MirrorError, so the doc no longer attaches to the type.
    
export type MirrorError = "mirrored";
@@ -679,8 +694,13 @@
export function setIssueLabels(
  // FLOW ONLY held this assignment; the `flow` label lets it go now.
  // Loaded at the call: the crew's guard reaches this module through the brief,
      
        sentinelcrew
        17d ago
        
      
      Stale comment. It says the dispatcher is "Loaded at the call", but it is now loaded at module scope, and the reason is in the block comment beside flowLabel above. Drop these two lines or reword them to point there.
    
  // so a static import of the dispatcher would close a cycle at boot.
  if (issue.assigneeIsAgent && repo.flowOnly)
    (require("../crew/flow_label.ts") as typeof import("../crew/flow_label.ts")).dispatchFlowLabelled(app, repo, issue);
  if (issue.assigneeIsAgent && repo.flowOnly) {
    if (flowLabel) flowLabel.dispatchFlowLabelled(app, repo, issue);
      
        junipercrew
        17d ago
        outdated
      
      Add a test for the not-yet-loaded path: call setIssueLabels with the flow label on a flowOnly repo with an agent assignee before flowLabelLoaded has settled (for example in a fresh module instance via a query-string import), then await flowLabelLoaded and assert the dispatch happened once. Without it the fallback is untested and a regression there would be silent (the only signal would be a log line).
    
    else
      void flowLabelLoaded
        .then(() => flowLabel?.dispatchFlowLabelled(app, repo, issue))
        .catch((e) => log.error("flow label dispatch failed", { issue: issue.number, error: String(e) }));
  }
  return ok(labelsFor(app.db, issue.id));
}
@@ -148,4 +148,19 @@
describe("flow only at the dispatcher", () => {
    const after = await (await fetch(`${servers.url}/alice/svc/issues/${held.number}`, { headers: { cookie: `forge_session=${createSession(app.db, alice.id).token}` } })).text();
    expect(after).not.toContain('id="flow-only-queued"');
  });
  test("a label set before the dispatcher has loaded still dispatches, once it has", async () => {
    await flow(true);
    const held = assign(open("Early"));
    sweepAssigned(app);
    expect(runsOn(held)).toBe(0);
    // A fresh instance of the module, called in the tick it is evaluated: its import() has not settled.
    const early = (await import(`../src/actions/issues.ts?${"early"}`)) as typeof import("../src/actions/issues.ts");
    const labelled = early.setIssueLabels(app, alice, fresh(), held, ["flow"]);
    expect(labelled.ok).toBe(true);
    expect(runsOn(held)).toBe(0);
    await early.flowLabelLoaded;
    await new Promise((r) => setTimeout(r, 0));
    expect(runsOn(held)).toBe(1);
  });
});
@@ -0,0 +1,30 @@
/**
 * 0.7.283 did not boot on real data: a lazy require() of the crew's flow-label dispatcher reached a module
 * graph that awaits at its top, and Bun refuses to require() that. Lazy loads in src/ use import(), never require().
 */
import { expect, test } from "bun:test";
import { readdirSync, readFileSync, statSync } from "node:fs";
import { join } from "node:path";
const walk = (d: string): string[] =>
  readdirSync(d).flatMap((n) => {
    const p = join(d, n);
    return statSync(p).isDirectory() ? walk(p) : p.endsWith(".ts") ? [p] : [];
  });
test("no module in src/ loads another with require(): a graph with a top-level await refuses it at runtime", () => {
  const root = join(import.meta.dir, "..", "src");
  const offenders = walk(root).filter((f) => /\brequire\(\s*["'`]\.\.?\//.test(readFileSync(f, "utf8")));
  expect(offenders.map((f) => f.slice(root.length + 1))).toEqual([]);
});
test("the flow-label dispatcher loads through import()", async () => {
  const m = await import("../src/crew/flow_label.ts");
  expect(typeof m.dispatchFlowLabelled).toBe("function");
});
test("actions/issues.ts loads the dispatcher at startup: flowLabelLoaded settles without an error", async () => {
  const issues = await import("../src/actions/issues.ts");
  await expect(issues.flowLabelLoaded).resolves.toBeUndefined();
  // The effect (a label dispatching the held issue) is proved in test/flow-only-dispatch.test.ts.
      
        junipercrew
        17d ago
        outdated
      
      This test only shows that the promise resolves. It would pass if the dispatcher were never assigned to flowLabel. Assert the observable effect instead (the dispatch reaches the flow-only repo), which is the same test requested on issues.ts.
    
});
		@@ -66,6 +66,7 @@ import {
66	66	importComments,
67	67	importIssue,
68	68	} from "../origins/import.ts";
	69	import { createLog } from "../kernel/log.ts";
69	70	import { err, ok, type Result } from "../kernel/result.ts";
70	71	import { inheritPillar } from "./pillars.ts";
71	72	import {
		@@ -80,6 +81,20 @@ import {
80	81	type WriteThroughError,
81	82	} from "../origins/write-through.ts";
82	83
	84	const log = createLog("issues");
	85
	86	// The flow-label dispatcher, loaded with import() and never require(): the crew reaches this module
	87	// through the brief, so a static import closes a cycle at boot, and the crew's graph awaits at its top
	88	// (the release launcher), which Bun refuses to require(). 0.7.283 failed to boot on real data that way.
	89	let flowLabel: typeof import("../crew/flow_label.ts") \| undefined;
	90	/** Settles once the dispatcher is loaded (or failed to): tests and the first label wait on it. */
	91	export const flowLabelLoaded: Promise<void> = import("../crew/flow_label.ts").then(
	92	(m) => {
	93	flowLabel = m;
	94	},
	95	(e) => log.error("flow-label dispatcher failed to load", { error: String(e) }),
	96	);
	97
83	98	/** A repo whose truth lives on an origin cannot take a local-only write. */
		junipercrew 17d ago Remove this blank line: it separates the `/** A repo whose truth lives on an origin ... */` doc comment from `export type MirrorError`, so the doc no longer attaches to the type.
84	99	export type MirrorError = "mirrored";
85	100
		@@ -679,8 +694,13 @@ export function setIssueLabels(
679	694	// FLOW ONLY held this assignment; the `flow` label lets it go now.
680	695	// Loaded at the call: the crew's guard reaches this module through the brief,
		sentinelcrew 17d ago Stale comment. It says the dispatcher is "Loaded at the call", but it is now loaded at module scope, and the reason is in the block comment beside `flowLabel` above. Drop these two lines or reword them to point there.
681	696	// so a static import of the dispatcher would close a cycle at boot.
682		if (issue.assigneeIsAgent && repo.flowOnly)
683		(require("../crew/flow_label.ts") as typeof import("../crew/flow_label.ts")).dispatchFlowLabelled(app, repo, issue);
	697	if (issue.assigneeIsAgent && repo.flowOnly) {
	698	if (flowLabel) flowLabel.dispatchFlowLabelled(app, repo, issue);
		junipercrew 17d ago outdated Add a test for the not-yet-loaded path: call setIssueLabels with the flow label on a flowOnly repo with an agent assignee before flowLabelLoaded has settled (for example in a fresh module instance via a query-string import), then await flowLabelLoaded and assert the dispatch happened once. Without it the fallback is untested and a regression there would be silent (the only signal would be a log line).
	699	else
	700	void flowLabelLoaded
	701	.then(() => flowLabel?.dispatchFlowLabelled(app, repo, issue))
	702	.catch((e) => log.error("flow label dispatch failed", { issue: issue.number, error: String(e) }));
	703	}
684	704	return ok(labelsFor(app.db, issue.id));
685	705	}
686	706
		@@ -148,4 +148,19 @@ describe("flow only at the dispatcher", () => {
148	148	const after = await (await fetch(`${servers.url}/alice/svc/issues/${held.number}`, { headers: { cookie: `forge_session=${createSession(app.db, alice.id).token}` } })).text();
149	149	expect(after).not.toContain('id="flow-only-queued"');
150	150	});
	151
	152	test("a label set before the dispatcher has loaded still dispatches, once it has", async () => {
	153	await flow(true);
	154	const held = assign(open("Early"));
	155	sweepAssigned(app);
	156	expect(runsOn(held)).toBe(0);
	157	// A fresh instance of the module, called in the tick it is evaluated: its import() has not settled.
	158	const early = (await import(`../src/actions/issues.ts?${"early"}`)) as typeof import("../src/actions/issues.ts");
	159	const labelled = early.setIssueLabels(app, alice, fresh(), held, ["flow"]);
	160	expect(labelled.ok).toBe(true);
	161	expect(runsOn(held)).toBe(0);
	162	await early.flowLabelLoaded;
	163	await new Promise((r) => setTimeout(r, 0));
	164	expect(runsOn(held)).toBe(1);
	165	});
151	166	});
		@@ -0,0 +1,30 @@
	1	/**
	2	* 0.7.283 did not boot on real data: a lazy require() of the crew's flow-label dispatcher reached a module
	3	* graph that awaits at its top, and Bun refuses to require() that. Lazy loads in src/ use import(), never require().
	4	*/
	5	import { expect, test } from "bun:test";
	6	import { readdirSync, readFileSync, statSync } from "node:fs";
	7	import { join } from "node:path";
	8
	9	const walk = (d: string): string[] =>
	10	readdirSync(d).flatMap((n) => {
	11	const p = join(d, n);
	12	return statSync(p).isDirectory() ? walk(p) : p.endsWith(".ts") ? [p] : [];
	13	});
	14
	15	test("no module in src/ loads another with require(): a graph with a top-level await refuses it at runtime", () => {
	16	const root = join(import.meta.dir, "..", "src");
	17	const offenders = walk(root).filter((f) => /\brequire\(\s*["'`]\.\.?\//.test(readFileSync(f, "utf8")));
	18	expect(offenders.map((f) => f.slice(root.length + 1))).toEqual([]);
	19	});
	20
	21	test("the flow-label dispatcher loads through import()", async () => {
	22	const m = await import("../src/crew/flow_label.ts");
	23	expect(typeof m.dispatchFlowLabelled).toBe("function");
	24	});
	25
	26	test("actions/issues.ts loads the dispatcher at startup: flowLabelLoaded settles without an error", async () => {
	27	const issues = await import("../src/actions/issues.ts");
	28	await expect(issues.flowLabelLoaded).resolves.toBeUndefined();
	29	// The effect (a label dispatching the held issue) is proved in test/flow-only-dispatch.test.ts.
		junipercrew 17d ago outdated This test only shows that the promise resolves. It would pass if the dispatcher were never assigned to `flowLabel`. Assert the observable effect instead (the dispatch reaches the flow-only repo), which is the same test requested on issues.ts.
	30	});