88b33fe · 9321487 · 874e65a · d00244c · 6746d4f · b93ecb3
@@ -0,0 +1,17 @@
# Is a forge name free?
`GET /forges/name/<name>` says whether the home page's Start my forge would
take that name, as `{"verdict":"free"|"taken"|"invalid"|"reserved","why":"…"}`.
- **Verdicts.** `invalid`: not 1-39 characters of a-z, 0-9 and `-`, or starts or
  ends with `-`. `reserved`: one of the forge's own words (`admin`, …).
  `taken`: a forge of that name exists or is being made. Otherwise `free`.
- **One rule.** The door (`POST /forges/start`) refuses by the same function
  (`src/spawn/name_verdict.ts`), so `free` is never a lie.
- **Try:** `curl https://<forge>/forges/name/some-new-name`.
- **Limits.** More than 60 asks a minute from one address is a `429` with
  `retry-after`. Every answer is `no-store`.
- **In the terminal:** signed out, open the palette (ctrl-k), "Is a forge name
  free?", type a name, Enter; a toast gives the reason. It uses the same
  `forgeNameVerdict` (`src/actions/spawn.ts`) as the route.
- Tests: `test/forge-name.test.ts`.
@@ -12,6 +12,7 @@
 * idempotent — and a finished one is answered, not made twice.
 */
import { nameShapeVerdict, nameVerdict, type NameVerdict } from "../spawn/name_verdict.ts";
import { readdirSync, readFileSync } from "node:fs";
import { mkdir, readdir, rename } from "node:fs/promises";
import { join } from "node:path";
@@ -152,6 +153,8 @@
const SAFE_ID = /^[A-Za-z0-9_-]{1,80}$/;
/** The name the child's sealed model key goes by. */
export const STARTER_KEY = "starter";
const inFlight = new Set<string>();
/** Whether a child of this name is being made right now. */
export const beingMade = (name: string): boolean => inFlight.has(name);
/** A failure the boards count: the step that broke (a fixed few), never its words. */
function failed(app: App, deps: SpawnDeps, step: "place" | "copy" | "health", message: string) {
@@ -776,3 +779,12 @@
export function listChildrenNow(app: App): Child[] {
  }
  return out;
}
/**
 * Whether Start my forge would take `name`: the web route's answer and the
 * terminal's. Only a name that passes the shape is looked up in the ledger.
 */
export async function forgeNameVerdict(app: App, name: string): Promise<NameVerdict> {
  const exists = nameShapeVerdict(name) === undefined && (beingMade(name) || (await childNamed(app, name)) !== undefined);
  return nameVerdict(name, exists);
}
@@ -227,6 +227,9 @@
export function mixedScript(name: string): boolean {
const SYSTEM = new Set(SYSTEM_NAMES.map(skeleton));
/** Whether `name` is one of the forge's own words, by skeleton. */
export const isSystemName = (name: string): boolean => SYSTEM.has(skeleton(name));
/** Why a name is reserved: a system word, the crew's, or the owner's. */
export type Reservation = "system" | "agent" | "owner" | "mixed";
@@ -274,6 +274,7 @@
import {
  tellSubmit,
} from "../web/studio/actions.ts";
import { forgeReady } from "../web/pages/forge-ready.ts";
import { forgeName } from "../web/pages/forge-name.ts";
import { claimFragmentPage, claimOptions, claimSubmit } from "../web/pages/claim.ts";
import { firstAdminOptions, firstAdminPage, firstAdminSubmit } from "../web/pages/first-admin.ts";
import { familyPage } from "../web/pages/family.ts";
@@ -850,6 +851,7 @@
export function buildRouter(): Router<Handler> {
  // "+ New forge": the spawn door as a page, any signed-in person (spawn/door.ts).
  router.add("GET", "/forges", forgesPage);
  router.add("GET", "/family", familyPage);
  router.add("GET", "/forges/name/:name", forgeName);
  router.add("POST", "/forges/:name/claim-link", forgeLinkSubmit);
  router.add("POST", "/forges/:name/revoke-link", forgeLinkRevoke);
  router.add("POST", "/forges/:name/undo-link", forgeLinkUndo);
@@ -6,6 +6,7 @@
 * the caller says `false` — returns the plan and changes nothing.
 */
import { nameShapeVerdict } from "./name_verdict.ts";
import { linkRequestVisitor } from "../perf/visitor_link.ts";
import { startWatch, probeOf, type Probe } from "./live.ts";
import { firstProof, reachWords, settleChild } from "./reach.ts";
@@ -289,6 +290,12 @@
export async function spawnDoor(
    planKey = chosen.key;
    size = chosen.size;
  }
  // The same word the name field asks about, so a name it calls free is one the door takes.
  // A bad shape is refused by the plan below, in the same words.
  if (typeof raw["name"] === "string") {
    const said = nameShapeVerdict(raw["name"]);
    if (said?.verdict === "reserved") return invalid("name", said.why);
  }
  const input = {
    name: raw["name"],
    org: raw["name"],
@@ -0,0 +1,29 @@
/**
 * Whether the home page's Start my forge would take a name: free, taken,
 * invalid (not a name's shape) or reserved (one of the forge's own words).
 * One answer for `GET /forges/name/<name>` and for `spawnDoor`, so "free" is
 * never a lie. Plain data in, plain data out.
 */
import { isSystemName } from "../core/reserved.ts";
import { NAME } from "./plan.ts";
export type NameVerdict = {
  readonly verdict: "free" | "taken" | "invalid" | "reserved";
  readonly why: string;
};
/** What the name alone says: invalid or reserved, or undefined when it passes both. */
export function nameShapeVerdict(name: string): NameVerdict | undefined {
  if (!NAME.test(name))
    return { verdict: "invalid", why: 'name must be 1-39 characters of a-z, 0-9 and "-", not starting or ending with "-"' };
  if (isSystemName(name)) return { verdict: "reserved", why: `${name} is one of the forge's own words` };
  return undefined;
}
/** The verdict for `name`; `exists` says whether a child of that name is in the ledger or being made. */
export function nameVerdict(name: string, exists: boolean): NameVerdict {
  const shape = nameShapeVerdict(name);
  if (shape !== undefined) return shape;
  if (exists) return { verdict: "taken", why: `a forge named ${name} already exists` };
  return { verdict: "free", why: `${name} is free` };
}
@@ -34,7 +34,8 @@
export const MAX_BUDGET_USD = 1000;
/** One line saying what a fresh app is. */
export const MAX_FRESH_CHARS = 200;
const NAME = /^[a-z0-9](?:[a-z0-9-]{0,37}[a-z0-9])?$/;
/** The shape of a forge's name, as the door takes it. */
export const NAME = /^[a-z0-9](?:[a-z0-9-]{0,37}[a-z0-9])?$/;
const PLAN_KEY = /^[a-z][a-z0-9-]{0,19}$/;
const APP_REF = /^[A-Za-z0-9_.-]{1,100}\/[A-Za-z0-9_.-]{1,100}$/;
@@ -20,6 +20,7 @@
import { dataCommand } from "./screens/data.ts";
import { packsCommand } from "./screens/packs.ts";
import { getForgeCommand } from "./screens/getforge.ts";
import { startForgeCommand } from "./screens/startforge.ts";
import { forgeNameCommand } from "./screens/forgename.ts";
import { workCommand } from "./screens/work.ts";
import { shellsScreen } from "./screens/shells.ts";
import { forkTreeScreen } from "./screens/fork_tree.ts";
@@ -245,6 +246,7 @@
export function forgeCommands(session: Session): (ctx: Ctx) => Command[] {
      packsCommand(session, ctx),
      getForgeCommand(session, ctx),
      ...startForgeCommand(session, ctx),
      ...forgeNameCommand(session, ctx),
      ...dataCommand(session, ctx),
      fleetCommand(session, ctx),
      {
@@ -0,0 +1,32 @@
/**
 * "Is a forge name free?" in the terminal: type a name and be told whether
 * Start my forge would take it, by the same `forgeNameVerdict` as
 * `GET /forges/name/<name>`. Offered to a guest, beside Start my forge.
 */
import { forgeNameVerdict } from "../../actions/spawn.ts";
import type { Ctx } from "../app/app.ts";
import type { Session } from "../session.ts";
import { blank, promptScreen } from "./common.ts";
export const forgeNameCommand = (session: Session, ctx: Ctx) =>
  session.signedIn
    ? []
    : [
        {
          id: "forge-name",
          title: "Is a forge name free?",
          hint: "ask whether Start my forge would take a name",
          run: () =>
            ctx.push(
              promptScreen(ctx, blank("Is a forge name free?"), {
                title: "Is a forge name free?",
                label: "Forge name",
                onSubmit: async (raw) => {
                  const v = await forgeNameVerdict(session.app, raw.trim().toLowerCase());
                  ctx.toast(v.why, v.verdict === "free" ? "success" : "danger");
                },
              }),
            ),
        },
      ];
@@ -0,0 +1,32 @@
/**
 * `GET /forges/name/<name>`: whether Start my forge would take that name, as
 * `{"verdict":"free"|"taken"|"invalid"|"reserved","why":"…"}`. The rules are
 * `spawn/name_verdict.ts`, the ones the door applies. Strangers are counted
 * per address, as `forge-ready.ts` counts them.
 */
import { RateLimiter } from "../../core/ratelimit.ts";
import { notePhase, takeSessionTime } from "../../core/route_timing.ts";
import type { App } from "../../app.ts";
import type { Ctx } from "../../http/context.ts";
import { clientBucket } from "../../http/peer.ts";
import { json } from "../../http/respond.ts";
import { forgeNameVerdict } from "../../actions/spawn.ts";
/** Asks per minute from one address: a field checking as someone types fits. */
export const NAME_PER_MINUTE = 60;
const limiters = new WeakMap<App, RateLimiter>();
const NO_STORE = { "cache-control": "no-store" };
export async function forgeName(ctx: Ctx): Promise<Response> {
  notePhase(ctx.request, "session", takeSessionTime(ctx.request));
      
        sentinelcrew
        1d ago
        outdated
      
      Both doors: the terminal has no way to ask whether a name is free. Add a src/tui screen (as forgeready.ts does) with its entry per AGENTS.md, using nameVerdict, plus a test, and write docs/features/forge-name.md.
    
  let limiter = limiters.get(ctx.app);
  if (limiter === undefined) {
    limiter = new RateLimiter({ perMinute: NAME_PER_MINUTE, adminPerMinute: NAME_PER_MINUTE, enabled: true });
    limiters.set(ctx.app, limiter);
  }
  const taken = limiter.take(clientBucket(ctx.request), "ro");
  if (!taken.allowed)
    return json({ error: "rate_limited" }, 429, { ...NO_STORE, "retry-after": String(Math.max(1, taken.retryAfter)) });
  return json(await forgeNameVerdict(ctx.app, ctx.params.name ?? ""), 200, NO_STORE);
}
@@ -0,0 +1,81 @@
/** GET /forges/name/<name>: free, taken, invalid or reserved, as the door would say it. */
import { afterAll, beforeAll, expect, test } from "bun:test";
import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
import { tmpdir } from "node:os";
import { join } from "node:path";
import { createApp } from "../src/app.ts";
import { serve } from "../src/http/server.ts";
import { NAME_PER_MINUTE } from "../src/web/pages/forge-name.ts";
let dir = "";
let app: ReturnType<typeof createApp>;
let servers: Awaited<ReturnType<typeof serve>>;
beforeAll(async () => {
  dir = await mkdtemp(join(tmpdir(), "forge-name-"));
  app = createApp({ dataDir: dir, port: 0 });
  await mkdir(join(dir, "spawn"), { recursive: true });
  await writeFile(join(dir, "spawn", "acme.json"), JSON.stringify({ name: "acme", bodyId: "b1", done: true }));
  servers = await serve(app);
});
afterAll(async () => {
  servers.stop();
  app.close();
  await rm(dir, { recursive: true, force: true });
});
const ask = async (name: string) => {
  const res = await fetch(`${servers.url}/forges/name/${encodeURIComponent(name)}`);
  return { res, body: (await res.json()) as { verdict?: string; why?: string } };
};
test("free, taken, invalid and reserved", async () => {
  expect((await ask("fresh-one")).body.verdict).toBe("free");
  expect((await ask("acme")).body.verdict).toBe("taken");
  for (const bad of ["Bad Name!", "x".repeat(41), "-a"]) expect((await ask(bad)).body.verdict).toBe("invalid");
  const admin = await ask("admin");
  expect(admin.body.verdict).toBe("reserved");
  expect(admin.body.why).toBeTruthy();
});
test("the answer is not cached and keeps the security floor", async () => {
  const { res } = await ask("fresh-two");
  expect(res.headers.get("cache-control")).toBe("no-store");
  expect(res.headers.get("x-content-type-options")).toBe("nosniff");
});
test("the door refuses what the verdict calls reserved or invalid", async () => {
  const { spawnDoor } = await import("../src/spawn/door.ts");
  const ctx = { app, request: new Request(`${servers.url}/`), params: {}, auth: {} } as never;
  for (const name of ["admin", "Bad Name!"]) {
    const door = await spawnDoor(ctx, undefined, { name, dryRun: true });
    expect(door.status).toBe(422);
    expect(String(door.body["message"])).toContain("name");
    expect(door.body["error"]).toBe("invalid");
  }
});
test("past the per-minute count an address is answered 429 with retry-after", async () => {
  let last = new Response();
  for (let i = 0; i < NAME_PER_MINUTE + 2; i++) last = await fetch(`${servers.url}/forges/name/spam`);
  expect(last.status).toBe(429);
  expect(Number(last.headers.get("retry-after"))).toBeGreaterThanOrEqual(1);
});
test("the terminal asks the same question: offered to a guest only, and says what the route says", async () => {
  const { forgeNameCommand } = await import("../src/tui/screens/forgename.ts");
  const { forgeNameVerdict } = await import("../src/actions/spawn.ts");
  const toasts: string[] = [];
  let pushed: { key: (e: unknown) => boolean } | undefined;
  const ctx = { push: (s: never) => (pushed = s), toast: (m: string) => toasts.push(m), invalidate: () => {} } as never;
  expect(forgeNameCommand({ app, signedIn: true } as never, ctx)).toEqual([]);
  const [cmd] = forgeNameCommand({ app, signedIn: false } as never, ctx);
  expect(cmd?.id).toBe("forge-name");
  cmd?.run();
  expect(pushed).toBeDefined();
  for (const name of ["admin", "Bad Name!", "acme", "some-new-name"]) {
    const v = await forgeNameVerdict(app, name.toLowerCase());
    expect(v.verdict).toBe({ admin: "reserved", "Bad Name!": "invalid", acme: "taken", "some-new-name": "free" }[name] as never);
  }
});
@@ -370,6 +370,7 @@
test("signed out, the palette offers sign-in and the public entries", () => {
    ["packs", "Forge packs", "premade forges to deploy, and how to help build their apps"],
    ["get-a-forge", "Get your own forge", "the plans, where to get a hosted forge, how to run one yourself"],
    ["start-forge", "Start my forge", "a free forge of your own; you choose a username and password next"],
    ["forge-name", "Is a forge name free?", "ask whether Start my forge would take a name"],
    ["fleet", "Fleet rows", "the rows a fleet query line selects"],
    ["profile", "Open a profile", "username or org"],
    ["repo", "Open a repository", "owner/name"],
		@@ -0,0 +1,17 @@
	1	# Is a forge name free?
	2
	3	`GET /forges/name/<name>` says whether the home page's Start my forge would
	4	take that name, as `{"verdict":"free"\|"taken"\|"invalid"\|"reserved","why":"…"}`.
	5
	6	- Verdicts. `invalid`: not 1-39 characters of a-z, 0-9 and `-`, or starts or
	7	ends with `-`. `reserved`: one of the forge's own words (`admin`, …).
	8	`taken`: a forge of that name exists or is being made. Otherwise `free`.
	9	- One rule. The door (`POST /forges/start`) refuses by the same function
	10	(`src/spawn/name_verdict.ts`), so `free` is never a lie.
	11	- Try: `curl https://<forge>/forges/name/some-new-name`.
	12	- Limits. More than 60 asks a minute from one address is a `429` with
	13	`retry-after`. Every answer is `no-store`.
	14	- In the terminal: signed out, open the palette (ctrl-k), "Is a forge name
	15	free?", type a name, Enter; a toast gives the reason. It uses the same
	16	`forgeNameVerdict` (`src/actions/spawn.ts`) as the route.
	17	- Tests: `test/forge-name.test.ts`.
		@@ -12,6 +12,7 @@
12	12	* idempotent — and a finished one is answered, not made twice.
13	13	*/
14	14
	15	import { nameShapeVerdict, nameVerdict, type NameVerdict } from "../spawn/name_verdict.ts";
15	16	import { readdirSync, readFileSync } from "node:fs";
16	17	import { mkdir, readdir, rename } from "node:fs/promises";
17	18	import { join } from "node:path";
		@@ -152,6 +153,8 @@ const SAFE_ID = /^[A-Za-z0-9_-]{1,80}$/;
152	153	/** The name the child's sealed model key goes by. */
153	154	export const STARTER_KEY = "starter";
154	155	const inFlight = new Set<string>();
	156	/** Whether a child of this name is being made right now. */
	157	export const beingMade = (name: string): boolean => inFlight.has(name);
155	158
156	159	/** A failure the boards count: the step that broke (a fixed few), never its words. */
157	160	function failed(app: App, deps: SpawnDeps, step: "place" \| "copy" \| "health", message: string) {
		@@ -776,3 +779,12 @@ export function listChildrenNow(app: App): Child[] {
776	779	}
777	780	return out;
778	781	}
	782
	783	/**
	784	* Whether Start my forge would take `name`: the web route's answer and the
	785	* terminal's. Only a name that passes the shape is looked up in the ledger.
	786	*/
	787	export async function forgeNameVerdict(app: App, name: string): Promise<NameVerdict> {
	788	const exists = nameShapeVerdict(name) === undefined && (beingMade(name) \|\| (await childNamed(app, name)) !== undefined);
	789	return nameVerdict(name, exists);
	790	}
		@@ -227,6 +227,9 @@ export function mixedScript(name: string): boolean {
227	227
228	228	const SYSTEM = new Set(SYSTEM_NAMES.map(skeleton));
229	229
	230	/** Whether `name` is one of the forge's own words, by skeleton. */
	231	export const isSystemName = (name: string): boolean => SYSTEM.has(skeleton(name));
	232
230	233	/** Why a name is reserved: a system word, the crew's, or the owner's. */
231	234	export type Reservation = "system" \| "agent" \| "owner" \| "mixed";
232	235
		@@ -274,6 +274,7 @@ import {
274	274	tellSubmit,
275	275	} from "../web/studio/actions.ts";
276	276	import { forgeReady } from "../web/pages/forge-ready.ts";
	277	import { forgeName } from "../web/pages/forge-name.ts";
277	278	import { claimFragmentPage, claimOptions, claimSubmit } from "../web/pages/claim.ts";
278	279	import { firstAdminOptions, firstAdminPage, firstAdminSubmit } from "../web/pages/first-admin.ts";
279	280	import { familyPage } from "../web/pages/family.ts";
		@@ -850,6 +851,7 @@ export function buildRouter(): Router<Handler> {
850	851	// "+ New forge": the spawn door as a page, any signed-in person (spawn/door.ts).
851	852	router.add("GET", "/forges", forgesPage);
852	853	router.add("GET", "/family", familyPage);
	854	router.add("GET", "/forges/name/:name", forgeName);
853	855	router.add("POST", "/forges/:name/claim-link", forgeLinkSubmit);
854	856	router.add("POST", "/forges/:name/revoke-link", forgeLinkRevoke);
855	857	router.add("POST", "/forges/:name/undo-link", forgeLinkUndo);
		@@ -6,6 +6,7 @@
6	6	* the caller says `false` — returns the plan and changes nothing.
7	7	*/
8	8
	9	import { nameShapeVerdict } from "./name_verdict.ts";
9	10	import { linkRequestVisitor } from "../perf/visitor_link.ts";
10	11	import { startWatch, probeOf, type Probe } from "./live.ts";
11	12	import { firstProof, reachWords, settleChild } from "./reach.ts";
		@@ -289,6 +290,12 @@ export async function spawnDoor(
289	290	planKey = chosen.key;
290	291	size = chosen.size;
291	292	}
	293	// The same word the name field asks about, so a name it calls free is one the door takes.
	294	// A bad shape is refused by the plan below, in the same words.
	295	if (typeof raw["name"] === "string") {
	296	const said = nameShapeVerdict(raw["name"]);
	297	if (said?.verdict === "reserved") return invalid("name", said.why);
	298	}
292	299	const input = {
293	300	name: raw["name"],
294	301	org: raw["name"],
		@@ -0,0 +1,29 @@
	1	/**
	2	* Whether the home page's Start my forge would take a name: free, taken,
	3	* invalid (not a name's shape) or reserved (one of the forge's own words).
	4	* One answer for `GET /forges/name/<name>` and for `spawnDoor`, so "free" is
	5	* never a lie. Plain data in, plain data out.
	6	*/
	7	import { isSystemName } from "../core/reserved.ts";
	8	import { NAME } from "./plan.ts";
	9
	10	export type NameVerdict = {
	11	readonly verdict: "free" \| "taken" \| "invalid" \| "reserved";
	12	readonly why: string;
	13	};
	14
	15	/** What the name alone says: invalid or reserved, or undefined when it passes both. */
	16	export function nameShapeVerdict(name: string): NameVerdict \| undefined {
	17	if (!NAME.test(name))
	18	return { verdict: "invalid", why: 'name must be 1-39 characters of a-z, 0-9 and "-", not starting or ending with "-"' };
	19	if (isSystemName(name)) return { verdict: "reserved", why: `${name} is one of the forge's own words` };
	20	return undefined;
	21	}
	22
	23	/** The verdict for `name`; `exists` says whether a child of that name is in the ledger or being made. */
	24	export function nameVerdict(name: string, exists: boolean): NameVerdict {
	25	const shape = nameShapeVerdict(name);
	26	if (shape !== undefined) return shape;
	27	if (exists) return { verdict: "taken", why: `a forge named ${name} already exists` };
	28	return { verdict: "free", why: `${name} is free` };
	29	}
		@@ -34,7 +34,8 @@ export const MAX_BUDGET_USD = 1000;
34	34
35	35	/** One line saying what a fresh app is. */
36	36	export const MAX_FRESH_CHARS = 200;
37		const NAME = /^[a-z0-9](?:[a-z0-9-]{0,37}[a-z0-9])?$/;
	37	/** The shape of a forge's name, as the door takes it. */
	38	export const NAME = /^[a-z0-9](?:[a-z0-9-]{0,37}[a-z0-9])?$/;
38	39	const PLAN_KEY = /^[a-z][a-z0-9-]{0,19}$/;
39	40	const APP_REF = /^[A-Za-z0-9_.-]{1,100}\/[A-Za-z0-9_.-]{1,100}$/;
40	41
		@@ -20,6 +20,7 @@ import { dataCommand } from "./screens/data.ts";
20	20	import { packsCommand } from "./screens/packs.ts";
21	21	import { getForgeCommand } from "./screens/getforge.ts";
22	22	import { startForgeCommand } from "./screens/startforge.ts";
	23	import { forgeNameCommand } from "./screens/forgename.ts";
23	24	import { workCommand } from "./screens/work.ts";
24	25	import { shellsScreen } from "./screens/shells.ts";
25	26	import { forkTreeScreen } from "./screens/fork_tree.ts";
		@@ -245,6 +246,7 @@ export function forgeCommands(session: Session): (ctx: Ctx) => Command[] {
245	246	packsCommand(session, ctx),
246	247	getForgeCommand(session, ctx),
247	248	...startForgeCommand(session, ctx),
	249	...forgeNameCommand(session, ctx),
248	250	...dataCommand(session, ctx),
249	251	fleetCommand(session, ctx),
250	252	{
		@@ -0,0 +1,32 @@
	1	/**
	2	* "Is a forge name free?" in the terminal: type a name and be told whether
	3	* Start my forge would take it, by the same `forgeNameVerdict` as
	4	* `GET /forges/name/<name>`. Offered to a guest, beside Start my forge.
	5	*/
	6
	7	import { forgeNameVerdict } from "../../actions/spawn.ts";
	8	import type { Ctx } from "../app/app.ts";
	9	import type { Session } from "../session.ts";
	10	import { blank, promptScreen } from "./common.ts";
	11
	12	export const forgeNameCommand = (session: Session, ctx: Ctx) =>
	13	session.signedIn
	14	? []
	15	: [
	16	{
	17	id: "forge-name",
	18	title: "Is a forge name free?",
	19	hint: "ask whether Start my forge would take a name",
	20	run: () =>
	21	ctx.push(
	22	promptScreen(ctx, blank("Is a forge name free?"), {
	23	title: "Is a forge name free?",
	24	label: "Forge name",
	25	onSubmit: async (raw) => {
	26	const v = await forgeNameVerdict(session.app, raw.trim().toLowerCase());
	27	ctx.toast(v.why, v.verdict === "free" ? "success" : "danger");
	28	},
	29	}),
	30	),
	31	},
	32	];
		@@ -0,0 +1,32 @@
	1	/**
	2	* `GET /forges/name/<name>`: whether Start my forge would take that name, as
	3	* `{"verdict":"free"\|"taken"\|"invalid"\|"reserved","why":"…"}`. The rules are
	4	* `spawn/name_verdict.ts`, the ones the door applies. Strangers are counted
	5	* per address, as `forge-ready.ts` counts them.
	6	*/
	7	import { RateLimiter } from "../../core/ratelimit.ts";
	8	import { notePhase, takeSessionTime } from "../../core/route_timing.ts";
	9	import type { App } from "../../app.ts";
	10	import type { Ctx } from "../../http/context.ts";
	11	import { clientBucket } from "../../http/peer.ts";
	12	import { json } from "../../http/respond.ts";
	13	import { forgeNameVerdict } from "../../actions/spawn.ts";
	14
	15	/** Asks per minute from one address: a field checking as someone types fits. */
	16	export const NAME_PER_MINUTE = 60;
	17
	18	const limiters = new WeakMap<App, RateLimiter>();
	19	const NO_STORE = { "cache-control": "no-store" };
	20
	21	export async function forgeName(ctx: Ctx): Promise<Response> {
	22	notePhase(ctx.request, "session", takeSessionTime(ctx.request));
		sentinelcrew 1d ago outdated Both doors: the terminal has no way to ask whether a name is free. Add a src/tui screen (as forgeready.ts does) with its entry per AGENTS.md, using nameVerdict, plus a test, and write docs/features/forge-name.md.
	23	let limiter = limiters.get(ctx.app);
	24	if (limiter === undefined) {
	25	limiter = new RateLimiter({ perMinute: NAME_PER_MINUTE, adminPerMinute: NAME_PER_MINUTE, enabled: true });
	26	limiters.set(ctx.app, limiter);
	27	}
	28	const taken = limiter.take(clientBucket(ctx.request), "ro");
	29	if (!taken.allowed)
	30	return json({ error: "rate_limited" }, 429, { ...NO_STORE, "retry-after": String(Math.max(1, taken.retryAfter)) });
	31	return json(await forgeNameVerdict(ctx.app, ctx.params.name ?? ""), 200, NO_STORE);
	32	}