@jant/core 0.7.0 → 0.7.1

package/src/__tests__/snapshot-tables.test.ts

@@ -0,0 +1,219 @@
+/**
+ * Snapshot Table Registry Guard
+ *
+ * `jant site snapshot export/import` walks two hand-written arrays in
+ * `bin/lib/site-snapshot.js`. Nothing connects them to `db/schema.ts`: `bin/`
+ * is plain JavaScript, outside the type system, so a new site-scoped table
+ * compiles, lints and tests clean while the snapshot silently skips it.
+ *
+ * That already happened. `smart_collection` arrived with migration 0033, and
+ * the commit that added it updated the schema, both dialects, five services, a
+ * route and three test files — but not these arrays. The damage was silent in
+ * both directions: export dropped smart collections, and `--replace` could not
+ * delete the ones a visitor created, so they outlived every nightly demo
+ * rebuild as rows with no slug and no nav entry.
+ *
+ * These tests close the gap. Every site-scoped table has to be named in one of
+ * the two registries, so a new table forces a decision instead of defaulting to
+ * "forgotten". The order assertions pin the arrays' other implicit contract:
+ * `SNAPSHOT_TABLES` is an INSERT order and `SNAPSHOT_CLEAR_TABLES` is a DELETE
+ * order, and both have to respect foreign keys — which are enforced, on D1 and
+ * on Node alike (`bin/lib/node-sqlite.js` sets `foreign_keys = ON`).
+ *
+ * Reading `db/schema.ts` alone covers both dialects: the registries are shared
+ * (only the dumped SQL is dialect-specific), and `db/pg/schema.ts` is required
+ * to declare the same tables.
+ */
+
+import { is } from "drizzle-orm";
+import { SQLiteTable, getTableConfig } from "drizzle-orm/sqlite-core";
+import { describe, expect, it } from "vitest";
+import {
+  SNAPSHOT_CLEAR_TABLES,
+  SNAPSHOT_EXCLUDED_TABLES,
+  SNAPSHOT_TABLES,
+  getSnapshotSelectSql,
+} from "../../bin/lib/site-snapshot.js";
+import {
+  TABLE_EXPORT_ORDER,
+  sortExportTables,
+} from "../../bin/lib/sql-export.js";
+import * as schema from "../db/schema.js";
+
+/** `site_setting` is cleared by key, not wholesale — see `buildReplaceSql`. */
+const CLEARED_BY_KEY = "site_setting";
+
+type SchemaTable = {
+  /** Physical table name, as it appears in SQL. */
+  name: string;
+  /** Tables this one points at with a foreign key, excluding self-references. */
+  dependsOn: string[];
+};
+
+/**
+ * Reads every site-scoped table out of the Drizzle schema with its foreign-key
+ * dependencies. "Site-scoped" means the table carries a `site_id` column, which
+ * is what makes a row belong to one site's content rather than the instance.
+ *
+ * @returns One entry per site-scoped table, in declaration order.
+ */
+function readSiteScopedTables(): SchemaTable[] {
+  const tables: SchemaTable[] = [];
+
+  for (const exported of Object.values(schema)) {
+    if (!is(exported, SQLiteTable)) continue;
+    const config = getTableConfig(exported);
+    if (!config.columns.some((column) => column.name === "site_id")) continue;
+
+    const dependsOn = [
+      ...new Set(
+        config.foreignKeys.map(
+          (foreignKey) =>
+            getTableConfig(foreignKey.reference().foreignTable).name,
+        ),
+      ),
+    ].filter((target) => target !== config.name);
+
+    tables.push({ name: config.name, dependsOn });
+  }
+
+  return tables;
+}
+
+const siteScopedTables = readSiteScopedTables();
+const siteScopedNames = siteScopedTables.map((table) => table.name);
+
+describe("snapshot table registry", () => {
+  it("covers every site-scoped table as content or an explicit exclusion", () => {
+    const registered = new Set<string>([
+      ...SNAPSHOT_TABLES,
+      ...SNAPSHOT_EXCLUDED_TABLES,
+    ]);
+    const unregistered = siteScopedNames.filter(
+      (name) => !registered.has(name),
+    );
+
+    expect(
+      unregistered,
+      [
+        "These site-scoped tables are in db/schema.ts but in neither snapshot registry.",
+        "A table the snapshot does not know about is dropped on export and survives",
+        "`--replace` on import. Add it to SNAPSHOT_TABLES if it is site content, or to",
+        "SNAPSHOT_EXCLUDED_TABLES with the reason if it is shell, credential or",
+        "transient state, in bin/lib/site-snapshot.js.",
+      ].join("\n"),
+    ).toEqual([]);
+  });
+
+  it("does not register a table as both content and excluded", () => {
+    const excluded = new Set<string>(SNAPSHOT_EXCLUDED_TABLES);
+    const both = SNAPSHOT_TABLES.filter((name) => excluded.has(name));
+
+    expect(both).toEqual([]);
+  });
+
+  it("can build an export query for every content table", () => {
+    // `getSnapshotSelectSql` has no default branch: a table listed as content
+    // without a matching statement throws "Unsupported snapshot table" at
+    // export time, which is the same silent-until-used failure the registry
+    // itself had.
+    for (const table of SNAPSHOT_TABLES) {
+      expect(() =>
+        getSnapshotSelectSql(table, "sit_00000000000000000000000000"),
+      ).not.toThrow();
+    }
+  });
+
+  it("does not keep registry entries for tables the schema dropped", () => {
+    const known = new Set(siteScopedNames);
+    const stale = [...SNAPSHOT_TABLES, ...SNAPSHOT_EXCLUDED_TABLES].filter(
+      (name) => !known.has(name),
+    );
+
+    expect(stale).toEqual([]);
+  });
+});
+
+describe("snapshot table ordering", () => {
+  it("registers every content table for export ordering", () => {
+    // A table missing here is not merely unordered: `sortExportTables` places
+    // unknown names after every known one, so a new child table is dumped
+    // behind its own parents and the import fails the first time a row exists
+    // to violate the constraint.
+    const ordered = new Set<string>(TABLE_EXPORT_ORDER);
+    expect(SNAPSHOT_TABLES.filter((name) => !ordered.has(name))).toEqual([]);
+  });
+
+  it("inserts a table only after every table it references", () => {
+    // The order an export actually follows. `SNAPSHOT_TABLES` is re-sorted by
+    // `TABLE_EXPORT_ORDER` on the way out, so asserting on the raw list would
+    // check something the dump ignores.
+    const position = new Map(
+      sortExportTables(SNAPSHOT_TABLES).map((name, index) => [name, index]),
+    );
+    const violations: string[] = [];
+
+    for (const table of siteScopedTables) {
+      const self = position.get(table.name);
+      if (self === undefined) continue;
+
+      for (const dependency of table.dependsOn) {
+        const parent = position.get(dependency);
+        if (parent === undefined) continue;
+        if (parent > self) {
+          violations.push(
+            `${table.name} (${self}) references ${dependency} (${parent})`,
+          );
+        }
+      }
+    }
+
+    expect(
+      violations,
+      [
+        "TABLE_EXPORT_ORDER in sql-export.js is the order rows are dumped, and so the",
+        "order they are inserted on import. A table has to come after everything it",
+        "points at with a foreign key, or the child row lands before its parent exists",
+        "and the insert fails the constraint.",
+      ].join("\n"),
+    ).toEqual([]);
+  });
+
+  it("deletes a table before every table it references", () => {
+    const position = new Map(
+      SNAPSHOT_CLEAR_TABLES.map((name, index) => [name, index]),
+    );
+    const violations: string[] = [];
+
+    for (const table of siteScopedTables) {
+      const self = position.get(table.name);
+      if (self === undefined) continue;
+
+      for (const dependency of table.dependsOn) {
+        const parent = position.get(dependency);
+        if (parent === undefined) continue;
+        if (parent < self) {
+          violations.push(
+            `${table.name} (${self}) references ${dependency} (${parent})`,
+          );
+        }
+      }
+    }
+
+    expect(
+      violations,
+      [
+        "SNAPSHOT_CLEAR_TABLES is the order rows are deleted by `--replace`, so a table",
+        "has to come before everything it points at. Deleting the parent first only",
+        "appears to work because the cascade takes the children with it — which is",
+        "implicit, and stops being true the moment a reference is not ON DELETE CASCADE.",
+      ].join("\n"),
+    ).toEqual([]);
+  });
+
+  it("clears every content table except the one cleared by key", () => {
+    expect([...SNAPSHOT_CLEAR_TABLES].sort()).toEqual(
+      SNAPSHOT_TABLES.filter((name) => name !== CLEARED_BY_KEY).sort(),
+    );
+  });
+});

package/src/__tests__/sql-export.test.ts

@@ -0,0 +1,173 @@
+/**
+ * The SQL dump behind `db export` and `site snapshot export`.
+ *
+ * On D1 every query goes through `wrangler d1 execute --json`, whose output
+ * the CLI buffers. One `SELECT *` of a real site's `post` table overflowed
+ * that buffer, so the dump reads D1 a page at a time.
+ */
+
+import { describe, expect, it } from "vitest";
+import Database from "better-sqlite3";
+import { dumpDatabaseToSql } from "../../bin/lib/sql-export.js";
+import { orderSnapshotPostRows } from "../../bin/lib/site-snapshot.js";
+import { describeWranglerFailure } from "../../bin/lib/d1-query.js";
+import { WRANGLER_MAX_BUFFER } from "../../bin/lib/wrangler-cli.js";
+
+function createQueryRunner() {
+  const db = new Database(":memory:");
+  db.exec(`
+    CREATE TABLE "post" ("id" TEXT PRIMARY KEY, "site_id" TEXT, "body" TEXT);
+  `);
+  const insert = db.prepare(
+    `INSERT INTO "post" ("id", "site_id", "body") VALUES (?, ?, ?)`,
+  );
+  for (let index = 0; index < 7; index += 1) {
+    insert.run(`pst_${index}`, "site", `body ${index}`);
+  }
+
+  const statements: string[] = [];
+  return {
+    statements,
+    runner: {
+      async query(sql: string) {
+        statements.push(sql);
+        return db.prepare(sql).all() as Record<string, unknown>[];
+      },
+    },
+  };
+}
+
+describe("dumpDatabaseToSql", () => {
+  it("reads a table in pages when given a page size", async () => {
+    const { runner, statements } = createQueryRunner();
+
+    const sql = await dumpDatabaseToSql(runner, {
+      source: "local",
+      dialect: "sqlite",
+      tables: ["post"],
+      pageSize: 3,
+    });
+
+    const reads = statements.filter((statement) =>
+      statement.includes('FROM "post"'),
+    );
+    expect(reads).toEqual([
+      'SELECT * FROM "post" ORDER BY rowid LIMIT 3 OFFSET 0',
+      'SELECT * FROM "post" ORDER BY rowid LIMIT 3 OFFSET 3',
+      'SELECT * FROM "post" ORDER BY rowid LIMIT 3 OFFSET 6',
+    ]);
+    for (let index = 0; index < 7; index += 1) {
+      expect(sql).toContain(`'pst_${index}'`);
+    }
+  });
+
+  it("pages a table's own ordered select", async () => {
+    const { runner, statements } = createQueryRunner();
+
+    const sql = await dumpDatabaseToSql(runner, {
+      source: "local",
+      dialect: "sqlite",
+      tables: ["post"],
+      pageSize: 5,
+      selectSqlByTable: {
+        post: `SELECT * FROM "post" WHERE "site_id" = 'site' ORDER BY "id"\n`,
+      },
+    });
+
+    expect(
+      statements.filter((statement) => statement.includes('FROM "post"')),
+    ).toEqual([
+      `SELECT * FROM "post" WHERE "site_id" = 'site' ORDER BY "id" LIMIT 5 OFFSET 0`,
+      `SELECT * FROM "post" WHERE "site_id" = 'site' ORDER BY "id" LIMIT 5 OFFSET 5`,
+    ]);
+    expect(sql.match(/INSERT INTO "post"/g)).toHaveLength(7);
+  });
+
+  it("reads a table in one query without a page size", async () => {
+    const { runner, statements } = createQueryRunner();
+
+    await dumpDatabaseToSql(runner, {
+      source: "node",
+      dialect: "sqlite",
+      tables: ["post"],
+    });
+
+    expect(
+      statements.filter((statement) => statement.includes('FROM "post"')),
+    ).toEqual(['SELECT * FROM "post"']);
+  });
+});
+
+describe("describeWranglerFailure", () => {
+  it("names the buffer overflow instead of echoing the rows", () => {
+    const error = Object.assign(new Error("spawnSync node ENOBUFS"), {
+      code: "ENOBUFS",
+      stdout: '[{"results":[' + '{"id":"pst_x","body":"…"},'.repeat(50_000),
+      stderr: "",
+    });
+
+    const message = describeWranglerFailure(
+      ["d1", "execute", "DB", "--local", "--json"],
+      error,
+    );
+
+    expect(message).toBe(
+      `\`wrangler d1 execute DB\` printed more than ${WRANGLER_MAX_BUFFER} bytes, the most the CLI buffers.`,
+    );
+  });
+
+  it("keeps a long failure's stdout to an excerpt", () => {
+    const message = describeWranglerFailure(["d1", "execute", "DB"], {
+      name: "Error",
+      message: "Command failed",
+      stdout: "x".repeat(10_000),
+      stderr: "",
+    } as Error & { stdout: string; stderr: string });
+
+    expect(message.length).toBeLessThan(2_200);
+    expect(message).toContain("(10000 characters)");
+  });
+});
+
+describe("snapshot post order", () => {
+  it("puts every post after its root and the post it replies to", () => {
+    const rows = [
+      { id: "reply-2", thread_id: "root", reply_to_id: "reply-1" },
+      { id: "reply-1", thread_id: "root", reply_to_id: "root" },
+      { id: "other", thread_id: "other", reply_to_id: null },
+      { id: "root", thread_id: "root", reply_to_id: null },
+    ];
+
+    expect(orderSnapshotPostRows(rows).map((row) => row.id)).toEqual([
+      "root",
+      "reply-1",
+      "reply-2",
+      "other",
+    ]);
+  });
+
+  it("keeps the dump order when parents already come first", () => {
+    const rows = [
+      { id: "a", thread_id: "a", reply_to_id: null },
+      { id: "b", thread_id: "a", reply_to_id: "a" },
+      { id: "c", thread_id: "c", reply_to_id: null },
+    ];
+
+    expect(orderSnapshotPostRows(rows)).toEqual(rows);
+  });
+
+  it("applies a table's row order to the dump", async () => {
+    const { runner } = createQueryRunner();
+
+    const sql = await dumpDatabaseToSql(runner, {
+      source: "node",
+      dialect: "sqlite",
+      tables: ["post"],
+      orderRowsByTable: {
+        post: (rows: Record<string, unknown>[]) => [...rows].reverse(),
+      },
+    });
+
+    expect(sql.indexOf("'pst_6'")).toBeLessThan(sql.indexOf("'pst_0'"));
+  });
+});

package/src/__tests__/zip-archive.test.ts

@@ -0,0 +1,106 @@
+/**
+ * Streaming ZIP helpers used by `site export`, `site import`,
+ * `site pull-media`, and `site snapshot`.
+ */
+
+import { createWriteStream } from "node:fs";
+import {
+  chmod,
+  mkdir,
+  mkdtemp,
+  readFile,
+  rm,
+  stat,
+  writeFile,
+} from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { pipeline } from "node:stream/promises";
+import { zipSync } from "fflate";
+import yazl from "yazl";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import {
+  extractZipFile,
+  writeDirectoryToZip,
+} from "../../bin/lib/zip-archive.js";
+
+describe("zip-archive", () => {
+  let tempDir: string;
+
+  beforeEach(async () => {
+    tempDir = await mkdtemp(join(tmpdir(), "jant-zip-"));
+  });
+
+  afterEach(async () => {
+    await chmod(join(tempDir, "source", "locked.md"), 0o644).catch(() => {});
+    await rm(tempDir, { recursive: true, force: true });
+  });
+
+  it("writes a directory and reads it back byte for byte", async () => {
+    const source = join(tempDir, "source");
+    const image = new Uint8Array(4096).map((_, index) => index % 251);
+    await mkdir(join(source, "content", "hello"), { recursive: true });
+    await mkdir(join(source, "static", "media"), { recursive: true });
+    await writeFile(
+      join(source, "hugo.toml"),
+      'baseURL = "https://a.example/"',
+    );
+    await writeFile(
+      join(source, "content", "hello", "_index.md"),
+      "---\n---\n你好",
+    );
+    await writeFile(join(source, "static", "media", "a.jpg"), image);
+
+    const zipPath = join(tempDir, "out", "site.zip");
+    expect(await writeDirectoryToZip(source, zipPath)).toEqual({ files: 3 });
+
+    const target = join(tempDir, "target");
+    expect(await extractZipFile(zipPath, target)).toEqual({ files: 3 });
+    expect(
+      await readFile(join(target, "content", "hello", "_index.md"), "utf8"),
+    ).toBe("---\n---\n你好");
+    expect(
+      new Uint8Array(await readFile(join(target, "static", "media", "a.jpg"))),
+    ).toEqual(image);
+  });
+
+  it("reads a ZIP64 archive", async () => {
+    const zipFile = new yazl.ZipFile();
+    zipFile.addBuffer(Buffer.from("big enough to need ZIP64"), "data/a.txt");
+    zipFile.end({ forceZip64Format: true });
+    const zipPath = join(tempDir, "zip64.zip");
+    await pipeline(zipFile.outputStream, createWriteStream(zipPath));
+
+    await extractZipFile(zipPath, join(tempDir, "target"));
+
+    expect(
+      await readFile(join(tempDir, "target", "data", "a.txt"), "utf8"),
+    ).toBe("big enough to need ZIP64");
+  });
+
+  it("refuses an entry that climbs out of the target directory", async () => {
+    const zipPath = join(tempDir, "escape.zip");
+    await writeFile(
+      zipPath,
+      zipSync({ "../escaped.txt": new TextEncoder().encode("x") }),
+    );
+
+    await expect(
+      extractZipFile(zipPath, join(tempDir, "target")),
+    ).rejects.toThrow();
+    await expect(stat(join(tempDir, "escaped.txt"))).rejects.toThrow();
+  });
+
+  it("leaves no archive behind when writing fails", async () => {
+    if (process.getuid?.() === 0) return; // root reads a mode-000 file anyway
+    const source = join(tempDir, "source");
+    await mkdir(source, { recursive: true });
+    await writeFile(join(source, "locked.md"), "secret");
+    await chmod(join(source, "locked.md"), 0o000);
+
+    const zipPath = join(tempDir, "site.zip");
+    await expect(writeDirectoryToZip(source, zipPath)).rejects.toThrow();
+    await expect(stat(zipPath)).rejects.toThrow();
+    await expect(stat(`${zipPath}.partial`)).rejects.toThrow();
+  });
+});

package/src/app.tsx

@@ -93,7 +93,7 @@ import {
 } from "./lib/jant-branding.js";
 import { isAssetPath } from "./lib/asset-path.js";
 import { getHostedCanonicalRedirect } from "./lib/hosted-domain.js";
-import { stripSitePathPrefix, toPublicHref } from "./lib/url.js";
+import { normalizePath, stripSitePathPrefix, toPublicHref } from "./lib/url.js";
 import {
   matchesIfNoneMatch,
   withConditionalResponse,
@@ -533,7 +533,13 @@ export function createApp(): App {
     await next();
   });
 
-  // Redirect middleware — only handles redirect-type custom URLs
+  // Redirect middleware — only handles redirect-type custom URLs.
+  //
+  // The lookup it needs is the same `path_registry` read the catch-all route
+  // makes to resolve a post or collection, so the record is stashed on the
+  // context and that route reuses it instead of asking again. Nothing between
+  // here and the route writes to the registry, so the record cannot go stale
+  // within the request.
   app.use("*", async (c, next) => {
     const path = new URL(c.req.url).pathname;
     // Skip redirect lookup for fixed machine routes and static assets.
@@ -541,17 +547,20 @@ export function createApp(): App {
       return next();
     }
 
-    const customUrl = await c.var.services.customUrls.getByPath(path.slice(1));
-    if (customUrl?.targetType === "redirect" && customUrl.toPath) {
+    const storedPath = normalizePath(path);
+    const record = await c.var.services.paths.resolve(storedPath);
+    c.set("pathLookup", { path: storedPath, record });
+
+    if (record?.kind === "redirect" && record.redirectToPath) {
       return c.redirect(
         toPublicHref(
-          customUrl.toPath,
+          `/${record.redirectToPath}`,
           getRuntimeSitePathPrefix({
             env: c.env,
             currentSiteDomain: c.var.currentSiteDomain,
           }),
         ),
-        customUrl.redirectType ?? 301,
+        record.redirectType ?? 301,
       );
     }
 

package/src/client/components/__tests__/jant-settings-avatar.test.ts

@@ -74,7 +74,7 @@ const labels: SettingsLabels = {
   discoverEnabled: "Allow Jant Discover to list my site",
   discoverIntro:
     "Jant Discover is a directory of Jant blogs, curated by hand by the Jant community to help people find new Jant blogs and posts. A post you mark Featured appears on the Discover home page 24 hours later, and link and quote posts appear on the Links and Quotes lists 24 hours after they are published. You can keep editing them in the meantime. See the Discover community rules.",
-  discoverDemoLocked: "Demo sites are never listed in Discover.",
+  discoverDemoLocked: "Demo sites are never listed in Jant Discover.",
   discoverFeedsOffLocked:
     "Discover reads your Atom feed, so it needs feeds turned on.",
   discoverSearchOff:

package/src/client/components/__tests__/jant-settings-general.test.ts

@@ -123,7 +123,7 @@ const labels: SettingsLabels = {
   discoverEnabled: "Allow Jant Discover to list my site",
   discoverIntro:
     "Jant Discover is a directory of Jant blogs, curated by hand by the Jant community to help people find new Jant blogs and posts. A post you mark Featured appears on the Discover home page 24 hours later, and link and quote posts appear on the Links and Quotes lists 24 hours after they are published. You can keep editing them in the meantime. See the Discover community rules.",
-  discoverDemoLocked: "Demo sites are never listed in Discover.",
+  discoverDemoLocked: "Demo sites are never listed in Jant Discover.",
   discoverFeedsOffLocked:
     "Discover reads your Atom feed, so it needs feeds turned on.",
   discoverSearchOff:
@@ -856,6 +856,26 @@ describe("JantSettingsGeneral", () => {
       expect(el.textContent).toContain(labels.discoverDemoLocked);
     });
 
+    // The notice replaces the help line, and with it the only link to the
+    // directory, so it carries that link itself.
+    it("links the directory from the demo notice", async () => {
+      const el = await createElement({ demoMode: true });
+      const notice = requireElement(
+        Array.from(el.querySelectorAll<HTMLElement>("p")).find(
+          (paragraph) =>
+            paragraph.textContent?.trim() === labels.discoverDemoLocked,
+        ) ?? null,
+        "expected the demo notice",
+      );
+      const links = Array.from(notice.querySelectorAll<HTMLAnchorElement>("a"));
+
+      expect(
+        links.map((link) => [link.textContent, link.getAttribute("href")]),
+      ).toEqual([[labels.discoverName, discoverPages.home]]);
+      expect(links[0]?.getAttribute("target")).toBe("_blank");
+      expect(links[0]?.getAttribute("rel")).toBe("noopener noreferrer");
+    });
+
     // Discover reads the Atom feed, so with feeds off there is nothing to read.
     it("locks the control off when the site publishes no feeds", async () => {
       const el = await createElement({ feedsEnabled: false });

package/src/client/components/jant-repo-picker-types.ts

@@ -1,6 +1,11 @@
 /**
  * Types shared between the server-side template and the
  * `jant-repo-picker` Lit component.
+ *
+ * Labels arrive translated and already formatted. A `{name}` left in one is
+ * deliberate: the value only exists in the browser, so the server keeps the
+ * token literal (see `keepForClient` in the settings route) and the component
+ * replaces it. Anything the server already knows is interpolated there.
  */
 
 export interface RepoPickerLabels {
@@ -20,7 +25,7 @@ export interface RepoPickerLabels {
   repoSearchHint: string;
   refreshRepos: string; // aria-label + tooltip for the refresh button
   createOnGitHub: string; // primary call-to-action text
-  createOnGitHubHint: string; // "We'll prefill the name {name} for you"
+  createOnGitHubHint: string; // repo name already interpolated
   classifyLoading: string;
   classificationEmpty: string;
   classificationOwned: string;

package/src/client/components/jant-repo-picker.ts

@@ -557,7 +557,7 @@ export class JantRepoPicker extends LitElement {
               <li>
                 <button
                   type="button"
-                  class="flex w-full items-center gap-2 px-3 py-2 text-left text-sm hover:bg-muted"
+                  class="flex w-full cursor-pointer items-center gap-2 px-3 py-2 text-left text-sm hover:bg-muted"
                   @click=${() => this.#selectOwner(inst)}
                   role="option"
                   aria-selected=${
@@ -692,7 +692,7 @@ export class JantRepoPicker extends LitElement {
                       <li>
                         <button
                           type="button"
-                          class="flex w-full items-center gap-2 px-3 py-2 text-left text-sm hover:bg-muted"
+                          class="flex w-full cursor-pointer items-center gap-2 px-3 py-2 text-left text-sm hover:bg-muted"
                           @click=${() => this.#selectRepo(r)}
                           role="option"
                           aria-selected=${
@@ -717,7 +717,7 @@ export class JantRepoPicker extends LitElement {
         <div class="border-t p-2">
           <button
             type="button"
-            class="flex w-full items-start gap-2 px-2 py-2 text-left text-sm text-primary hover:bg-muted rounded-md"
+            class="flex w-full cursor-pointer items-start gap-2 rounded-md px-2 py-2 text-left text-sm text-primary hover:bg-muted"
             @click=${() => this.#openCreateOnGitHub()}
           >
             <span class="flex flex-col">
@@ -725,10 +725,7 @@ export class JantRepoPicker extends LitElement {
               ${
                 this.createRepoNameHint
                   ? html`<span class="text-xs text-muted-foreground">
-                      ${this.labels.createOnGitHubHint.replace(
-                        "{name}",
-                        this.createRepoNameHint,
-                      )}
+                      ${this.labels.createOnGitHubHint}
                     </span>`
                   : nothing
               }