create-ailk 0.15.0 → 0.16.0

package/templates/apps/web/app/openapi.json/route.ts

@@ -23,6 +23,7 @@
  * host, and never calls a path this site would answer 404.
  */
 
+import { browserApiOrigin } from "../../lib/api-origin.generated";
 import { RELAY_ROUTES } from "../../lib/relay";
 import { TOPOLOGY } from "../../lib/topology.generated";
 import { resolveBaseUrl } from "../../src/lib/routes";
@@ -43,9 +44,7 @@ const LOCAL_API_ORIGIN = "http://localhost:3001";
  */
 function apiBase(): string {
   return stripSlash(
-    process.env["AILK_API_URL"] ||
-      process.env["NEXT_PUBLIC_AILK_API_URL"] ||
-      LOCAL_API_ORIGIN,
+    process.env["AILK_API_URL"] || browserApiOrigin() || LOCAL_API_ORIGIN,
   );
 }
 
@@ -55,9 +54,7 @@ function apiBase(): string {
  */
 function publicApiBase(): string {
   return stripSlash(
-    process.env["NEXT_PUBLIC_AILK_API_URL"] ||
-      process.env["AILK_API_URL"] ||
-      LOCAL_API_ORIGIN,
+    browserApiOrigin() || process.env["AILK_API_URL"] || LOCAL_API_ORIGIN,
   );
 }
 

package/templates/apps/web/auth.ts

@@ -134,13 +134,16 @@ function deferredPrismaForAuth(): PrismaClient {
 }
 
 /**
- * The one delegate method `onPasswordReset` reaches for, named so the call
+ * The two delegate methods `onPasswordReset` reaches for, named so the call
  * site needs no cast. Method shorthand for the same reason `AuthEmailPrisma`
  * uses it: the generated `PrismaClient` satisfies this structurally, and
- * nothing wider than `verification.deleteMany` is reachable through it.
+ * nothing wider than `verification.deleteMany` and
+ * `oAuthAuthorization.updateMany` is reachable through it. The second ends
+ * every credential a spoke holds for the person (#7894 D4, SEC-7894-5).
  */
 interface VerificationStore {
   verification: { deleteMany(args: unknown): Promise<unknown> };
+  oAuthAuthorization: { updateMany(args: unknown): Promise<unknown> };
 }
 
 type SocialProviders = {
@@ -364,6 +367,30 @@ export function createAuth(deps: CreateAuthDeps = {}) {
         })}`,
       );
     }
+    /**
+     * A completed reset also ends every credential a SPOKE holds for this
+     * person (#7894 D4, SEC-7894-5). A hub session an attacker held minted
+     * spoke credentials of its own; recovering the account must end those too,
+     * or the attacker keeps reading the person's data on every spoke for the
+     * rest of the credential's 24 hours. The same posture as the sibling
+     * delete above: the reset ALREADY SUCCEEDED, so a failed revoke is
+     * logged (the user id and a reason, never a credential) and never turns
+     * it into a 500.
+     */
+    try {
+      await verificationStore.oAuthAuthorization.updateMany({
+        where: { userId: user.id, revokedAt: null },
+        data: { revokedAt: new Date() },
+      });
+    } catch {
+      console.warn(
+        `[auth-email] ${JSON.stringify({
+          userId: user.id,
+          kind: "password-reset",
+          reason: "spoke_credential_revocation_failed",
+        })}`,
+      );
+    }
     /**
      * Guarded like its sibling above, though `lib/auth-email.ts` now also
      * guards its own signing step (#6068). BOTH, deliberately: this callback

package/templates/apps/web/components/sign-out-trigger.tsx

@@ -3,6 +3,11 @@
 /**
  * SignOutTrigger — wraps the signed-in Nav's "Sign out" trigger (#4984).
  *
+ * With an `endpoint` (a spoke that signs in through its hub, #7894 D10) it
+ * POSTs there — the hub-session sign-out, which revokes the credential and
+ * clears the session cookie — and navigates home only when that succeeded;
+ * without one it calls Better Auth's client exactly as before.
+ *
  * The locale layout (RSC) reads the session and authors the "Sign out" nav
  * action as `kind: "flow"`; Nav hands the rendered trigger `<Button>` back
  * through `renderFlowTrigger` — composed in `SignedInNav`, on the client side
@@ -22,16 +27,30 @@ export interface SignOutTriggerProps {
   children: ReactNode;
   /** Where to land after signing out. Defaults to the site home. */
   homeHref?: string;
+  /** A same-origin sign-out route to POST to instead of Better Auth's client. */
+  endpoint?: string;
 }
 
 export function SignOutTrigger({
   children,
   homeHref = "/",
+  endpoint,
 }: SignOutTriggerProps): ReactElement {
   const router = useRouter();
 
   const handleSignOut = async (): Promise<void> => {
-    await authClient.signOut();
+    if (endpoint !== undefined) {
+      // A refused or failed sign-out leaves the visitor signed in, so the
+      // page must not pretend otherwise by navigating away.
+      try {
+        const res = await fetch(endpoint, { method: "POST", credentials: "same-origin" });
+        if (!res.ok) return;
+      } catch {
+        return;
+      }
+    } else {
+      await authClient.signOut();
+    }
     router.push(homeHref);
     router.refresh();
   };

package/templates/apps/web/components/signed-in-nav.tsx

@@ -32,9 +32,19 @@ import { SignOutTrigger } from "./sign-out-trigger";
 export type SignedInNavProps = Omit<
   NavProps,
   "navItems" | "renderFlowTrigger" | "translate" | "onSearchOpen"
->;
+> & {
+  /**
+   * Where "Sign out" POSTs, from the generated seam's `SIGN_OUT_ENDPOINT`
+   * (#7894 D10) — a spoke that signs in through its hub. Absent or `null`,
+   * Sign out goes through Better Auth's client, as on a hub.
+   */
+  signOutEndpoint?: string | null;
+};
 
-export function SignedInNav(props: SignedInNavProps): ReactElement {
+export function SignedInNav({
+  signOutEndpoint,
+  ...props
+}: SignedInNavProps): ReactElement {
   return (
     <Nav
       {...props}
@@ -43,7 +53,11 @@ export function SignedInNav(props: SignedInNavProps): ReactElement {
       // SignOutTrigger, the account action a non-navigating name label.
       renderFlowTrigger={(action, trigger) =>
         action.labelKey === "signOut" ? (
-          <SignOutTrigger>{trigger}</SignOutTrigger>
+          <SignOutTrigger
+            {...(signOutEndpoint ? { endpoint: signOutEndpoint } : {})}
+          >
+            {trigger}
+          </SignOutTrigger>
         ) : (
           <span
             className="text-body-sm text-(--color-text-muted)"

package/templates/apps/web/lib/__tests__/account-config.test.ts

@@ -107,10 +107,12 @@ describe("account-config exports (AC-6)", () => {
     expect(Array.isArray(accountForYouSources)).toBe(true);
   });
 
-  it("ships exactly the two base Inbox kinds, both Recents rows (D6a, D9)", () => {
+  it("ships exactly the base Inbox kinds and the member kinds (#7920), all Recents rows (D6a, D9)", () => {
     expect(accountInboxKinds.map((k) => [k.kind, k.section])).toEqual([
       ["result", "updates"],
       ["purchase", "updates"],
+      ["piece", "updates"],
+      ["message", "updates"],
     ]);
     // Nothing in the base area fills Scheduled (the old Upcoming), and no
     // Inbox row asks for a decision — that is the For-you panel's job.
@@ -118,10 +120,11 @@ describe("account-config exports (AC-6)", () => {
     expect(accountInboxKinds.some((k) => k.section === "needs-you")).toBe(false);
   });
 
-  it("ships email-unverified and payment-due as For-you sources, not Inbox kinds (D9 as amended)", () => {
+  it("ships email-unverified, payment-due and piece-needs-client (#7920) as For-you sources, not Inbox kinds (D9 as amended)", () => {
     expect(accountForYouSources.map((s) => s.id)).toEqual([
       "email-unverified",
       "payment-due",
+      "piece-needs-client",
     ]);
     const kinds = accountInboxKinds.map((k) => k.kind);
     expect(kinds).not.toContain("email-unverified");

package/templates/apps/web/lib/__tests__/listings-config.test.ts

@@ -0,0 +1,83 @@
+/**
+ * The one reader of the listing site key (#7872 D8, AC-6).
+ *
+ * `NEXT_PUBLIC_AILK_LISTING_SITE_KEY` wins; `AILK_LISTING_PUBLIC_KEY` is the
+ * fallback every site configured since create-ailk 0.12.0 already sets; an
+ * empty or whitespace value counts as unset, so the listicle directory stays
+ * off rather than reading the hub with a blank key.
+ */
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+
+import { listingSiteKey, listingsEnabled } from "../listings-config";
+
+const PUBLIC_NAME = "NEXT_PUBLIC_AILK_LISTING_SITE_KEY";
+const FALLBACK_NAME = "AILK_LISTING_PUBLIC_KEY";
+
+const original = {
+  public: process.env[PUBLIC_NAME],
+  fallback: process.env[FALLBACK_NAME],
+};
+
+function setEnv(name: string, value: string | undefined): void {
+  if (value === undefined) delete process.env[name];
+  else process.env[name] = value;
+}
+
+afterEach(() => {
+  setEnv(PUBLIC_NAME, original.public);
+  setEnv(FALLBACK_NAME, original.fallback);
+});
+
+describe("listingSiteKey / listingsEnabled", () => {
+  it("answers the trimmed public name when both are set", () => {
+    setEnv(PUBLIC_NAME, "  site-public  ");
+    setEnv(FALLBACK_NAME, "site-fallback");
+
+    expect(listingSiteKey()).toBe("site-public");
+    expect(listingsEnabled()).toBe(true);
+  });
+
+  it("answers the trimmed fallback when only it is set", () => {
+    setEnv(PUBLIC_NAME, undefined);
+    setEnv(FALLBACK_NAME, " site-fallback\n");
+
+    expect(listingSiteKey()).toBe("site-fallback");
+    expect(listingsEnabled()).toBe(true);
+  });
+
+  it("falls back when the public name is whitespace only", () => {
+    setEnv(PUBLIC_NAME, "   ");
+    setEnv(FALLBACK_NAME, "site-fallback");
+
+    expect(listingSiteKey()).toBe("site-fallback");
+    expect(listingsEnabled()).toBe(true);
+  });
+
+  it("answers undefined when neither is set", () => {
+    setEnv(PUBLIC_NAME, undefined);
+    setEnv(FALLBACK_NAME, undefined);
+
+    expect(listingSiteKey()).toBeUndefined();
+    expect(listingsEnabled()).toBe(false);
+  });
+
+  it("answers undefined when both are empty or whitespace", () => {
+    setEnv(PUBLIC_NAME, "");
+    setEnv(FALLBACK_NAME, "  \t");
+
+    expect(listingSiteKey()).toBeUndefined();
+    expect(listingsEnabled()).toBe(false);
+  });
+});
+
+describe("apps/web/.env.example", () => {
+  it("documents both names", () => {
+    const example = readFileSync(
+      join(__dirname, "..", "..", ".env.example"),
+      "utf8",
+    );
+    expect(example).toMatch(new RegExp(`^# ${PUBLIC_NAME}=`, "m"));
+    expect(example).toMatch(new RegExp(`^# ${FALLBACK_NAME}=`, "m"));
+  });
+});

package/templates/apps/web/lib/__tests__/listings.test.tsx

@@ -294,6 +294,55 @@ describe("no read without a key or the paid package", () => {
   });
 });
 
+describe("the default key reader is listings-config's (#7872 D8)", () => {
+  const PUBLIC_NAME = "NEXT_PUBLIC_AILK_LISTING_SITE_KEY";
+  const FALLBACK_NAME = "AILK_LISTING_PUBLIC_KEY";
+  const original = { public: process.env[PUBLIC_NAME], fallback: process.env[FALLBACK_NAME] };
+
+  function setEnv(name: string, value: string | undefined): void {
+    if (value === undefined) delete process.env[name];
+    else process.env[name] = value;
+  }
+
+  /** Every dependency but the key: the extension falls back to its own reader. */
+  function keylessDepsExtension() {
+    return createListingExtension({
+      pathname: async () => path,
+      locales: () => ["en", "fr"],
+      fetchDirectory,
+      loadUi: async () => STUB_UI,
+      translate: async () => (key: string) => `listings.${key}`,
+      baseUrl: () => "https://site.test",
+    });
+  }
+
+  afterEach(() => {
+    setEnv(PUBLIC_NAME, original.public);
+    setEnv(FALLBACK_NAME, original.fallback);
+  });
+
+  it("reads the directory with NEXT_PUBLIC_AILK_LISTING_SITE_KEY", async () => {
+    setEnv(PUBLIC_NAME, "k");
+    setEnv(FALLBACK_NAME, undefined);
+    path = "/en/partners";
+
+    await keylessDepsExtension().appendix!({ type: "AboutPage", slug: "partners", locale: "en" });
+
+    expect(fetchDirectory).toHaveBeenCalledWith("k", "/partners", "en");
+  });
+
+  it("makes no read with neither variable set", async () => {
+    setEnv(PUBLIC_NAME, undefined);
+    setEnv(FALLBACK_NAME, undefined);
+    path = "/en/partners";
+
+    expect(
+      await keylessDepsExtension().appendix!({ type: "AboutPage", slug: "partners", locale: "en" }),
+    ).toBeNull();
+    expect(fetchDirectory).toHaveBeenCalledTimes(0);
+  });
+});
+
 describe("a failed read renders the page as today", () => {
   let warn: jest.SpyInstance;
   beforeEach(() => {

package/templates/apps/web/lib/__tests__/meeting-slugs.test.ts

@@ -1,7 +1,11 @@
 // oss: false
 /**
  * Tests for enabledMeetingSlugs (#6183 S9b D5) — the D4-resolving read both
- * /meet pages share.
+ * /meet pages share — and its spoke branch (#7872 D4).
+ *
+ * The topology seam is mocked: its hub render imports `../auth`, which this
+ * suite has no reason to load (`app/openapi.json/__tests__/route.test.ts`'s
+ * pattern).
  */
 const mockMeetingTypes = jest.fn();
 jest.mock("@working-theory/api-client", () => ({
@@ -9,6 +13,14 @@ jest.mock("@working-theory/api-client", () => ({
   schedule: { meetingTypes: (...args: unknown[]) => mockMeetingTypes(...args) },
 }));
 
+const mockTopology: { value: "hub" | "spoke" } = { value: "hub" };
+// eslint-disable-next-line no-restricted-syntax -- #507: the topology is a generated constant (#7426 D5), not a runtime input; the seam IS the boundary between a hub and a spoke build, and there is no env or HTTP surface that selects it.
+jest.mock("../topology.generated", () => ({
+  get TOPOLOGY() {
+    return mockTopology.value;
+  },
+}));
+
 import { enabledMeetingSlugs } from "../meeting-slugs";
 
 describe("enabledMeetingSlugs", () => {
@@ -16,6 +28,7 @@ describe("enabledMeetingSlugs", () => {
 
   beforeEach(() => {
     mockMeetingTypes.mockReset();
+    mockTopology.value = "hub";
   });
 
   afterEach(() => {
@@ -70,3 +83,38 @@ describe("enabledMeetingSlugs", () => {
     await expect(enabledMeetingSlugs()).resolves.toEqual([]);
   });
 });
+
+describe("enabledMeetingSlugs on a spoke (#7872 D4)", () => {
+  const originalEnv = process.env["SCHEDULING_CAL_LINK"];
+
+  beforeEach(() => {
+    mockMeetingTypes.mockReset();
+    mockTopology.value = "spoke";
+  });
+
+  afterEach(() => {
+    mockTopology.value = "hub";
+    if (originalEnv === undefined) delete process.env["SCHEDULING_CAL_LINK"];
+    else process.env["SCHEDULING_CAL_LINK"] = originalEnv;
+  });
+
+  it("null + SCHEDULING_CAL_LINK set → [], never the fallback: the hub books only a stored slug", async () => {
+    process.env["SCHEDULING_CAL_LINK"] = "acme/intro-call";
+    mockMeetingTypes.mockResolvedValue({ ok: true, body: { slugs: null } });
+
+    await expect(enabledMeetingSlugs()).resolves.toEqual([]);
+  });
+
+  it("passes the workspace's stored list through unchanged", async () => {
+    mockMeetingTypes.mockResolvedValue({ ok: true, body: { slugs: ["intro"] } });
+
+    await expect(enabledMeetingSlugs()).resolves.toEqual(["intro"]);
+  });
+
+  it("a non-ok API result → [], fail closed", async () => {
+    process.env["SCHEDULING_CAL_LINK"] = "acme/intro-call";
+    mockMeetingTypes.mockResolvedValue({ ok: false, status: 401, body: null });
+
+    await expect(enabledMeetingSlugs()).resolves.toEqual([]);
+  });
+});

package/templates/apps/web/lib/__tests__/relay.test.ts

@@ -513,6 +513,33 @@ describe("hardening — what the site serves, and a missing hub address", () =>
       expect(res.status).toBe(201);
       expect(fetchMock).toHaveBeenCalledTimes(1);
     });
+
+    // #7874 D12 — the fallback reads the browser API origin seam. The
+    // committed seam is the hub render, so this case runs it unmocked.
+    it("on a hub, NEXT_PUBLIC_AILK_API_URL alone still counts as a hub address", async () => {
+      delete process.env.AILK_API_URL;
+      process.env.NEXT_PUBLIC_AILK_API_URL = HUB;
+      const res = await handleRelay(relayRequest("/v1/leads/submit"));
+      expect(res.status).toBe(201);
+      expect(fetchMock).toHaveBeenCalledTimes(1);
+    });
+
+    it("on a spoke (the seam's spoke render), that fallback is skipped", async () => {
+      delete process.env.AILK_API_URL;
+      process.env.NEXT_PUBLIC_AILK_API_URL = HUB;
+      let res: Response | undefined;
+      await jest.isolateModulesAsync(async () => {
+        jest.doMock("../api-origin.generated", () => ({
+          browserApiOrigin: (): string | undefined => undefined,
+        }));
+        const spoke = await import("../relay");
+        res = await spoke.handleRelay(relayRequest("/v1/leads/submit"));
+      });
+      if (res === undefined) throw new Error("the spoke relay did not answer");
+      expect(res.status).toBe(502);
+      expect(await errorCode(res)).toBe("relay_unreachable");
+      expect(fetchMock).not.toHaveBeenCalled();
+    });
   });
 });
 

package/templates/apps/web/lib/account-config.ts

@@ -32,22 +32,41 @@
 // failure rejects — a 401/403 for a verified email included — so the area
 // shows an error row with Retry instead of an empty Inbox (D12). Scheduled
 // (the old Upcoming) stays empty in the base area; a module fills it.
+//
+// The member area's spoke leg (#7920) — the client's own records on the hub,
+// read by a spoke that signs its clients in through the hub (#7877, #7894):
+//
+//   - Inbox kinds `piece` (`GET /v1/member/pieces`) and `message`
+//     (`GET /v1/member/messages`). A message with a file has a file action to
+//     this site's own member file read, `account/inbox/message/[id]/file`,
+//     which re-serves the hub's bytes — the browser holds no hub credential.
+//   - For-you source `piece-needs-client` — each piece waiting on the client,
+//     with an Open action to its Inbox row. It shares the pieces read.
+//
+// The hub admits these reads only with the client's hub credential, which
+// `ctx.init` carries as `Authorization` on such a spoke and nowhere else. On a
+// cookie-session site (a hub, or a site with its own sign-in) there is none,
+// so the three make no call and load `[]` — inert, never an error row.
 
 import {
   flowCheckouts,
+  member,
   subscription,
   waitlistSignups,
   type FlowCheckoutMeItem,
   type WaitlistSignupMeResponse,
 } from "@working-theory/api-client";
 import type {
+  AccountContext,
   AccountForYouSource,
   AccountInboxKind,
   AccountSettingsSection,
   AccountUser,
 } from "@working-theory/templates/account";
 import { localeHref } from "@working-theory/ui";
+import type { MemberMessage, MemberPiece } from "@working-theory/validation";
 import { formatMoney, formatNumber } from "@working-theory/web-i18n";
+import { cache } from "react";
 
 import { unwrapApiResult } from "./server-api";
 
@@ -168,6 +187,92 @@ const purchase: AccountInboxKind<FlowCheckoutMeItem> = {
   },
 };
 
+// ── Member Inbox kinds (#7920) ───────────────────────────────────────────────
+
+/** Whether `init` carries the client's hub credential (see the header). */
+function hasHubCredential({ init }: AccountContext): boolean {
+  return Object.keys(init.headers).some((name) => name.toLowerCase() === "authorization");
+}
+
+/** One pieces read per request — the `piece` kind and the For-you source share it. */
+const memberPieces = cache((init: AccountContext["init"]) => member.pieces(init));
+
+async function loadPieces(ctx: AccountContext): Promise<MemberPiece[]> {
+  if (!hasHubCredential(ctx)) return [];
+  return (await read(memberPieces(ctx.init), ctx.user))?.items ?? [];
+}
+
+const piece: AccountInboxKind<MemberPiece> = {
+  kind: "piece",
+  label: "pieces.heading",
+  section: "updates",
+  async load(ctx) {
+    return (await loadPieces(ctx)).map((p) => ({
+      id: p.id,
+      title: p.title,
+      at: p.updatedAt,
+      data: p,
+    }));
+  },
+  renderDetail({ data }, { locale, t }) {
+    return {
+      status: data.stage,
+      ...(data.needsClient ? { lead: t("pieces.needsClient") } : {}),
+      fields: {
+        heading: t("pieces.heading"),
+        items: [
+          { label: t("pieces.stage"), value: data.stage },
+          { label: t("pieces.createdAt"), value: formatWhen(data.createdAt, locale) },
+          { label: t("pieces.updatedAt"), value: formatWhen(data.updatedAt, locale) },
+        ],
+      },
+    };
+  },
+};
+
+const message: AccountInboxKind<MemberMessage> = {
+  kind: "message",
+  label: "messages.heading",
+  section: "updates",
+  async load(ctx) {
+    if (!hasHubCredential(ctx)) return [];
+    const messages = (await read(member.messages(ctx.init), ctx.user))?.items ?? [];
+    return messages.map((m) => ({
+      id: m.id,
+      title: m.subject,
+      at: m.createdAt,
+      data: m,
+    }));
+  },
+  renderDetail({ data }, { locale, t }) {
+    return {
+      lead: data.body,
+      ...(data.file
+        ? {
+            actions: [
+              {
+                key: "file",
+                label: t("messages.download", { filename: data.file.filename }),
+                variant: "default" as const,
+                href: localeHref(
+                  locale,
+                  `/account/inbox/message/${encodeURIComponent(data.id)}/file`,
+                ),
+              },
+            ],
+          }
+        : {}),
+      fields: {
+        heading: t("messages.heading"),
+        items: [
+          { label: t("messages.sentAt"), value: formatWhen(data.createdAt, locale) },
+          ...(data.file ? [{ label: t("messages.file"), value: data.file.filename }] : []),
+        ],
+      },
+    };
+  },
+};
+
 // ── Base For-you sources (D9 as amended, D8a) ────────────────────────────────
 
 const emailUnverified: AccountForYouSource = {
@@ -206,10 +311,33 @@ const paymentDue: AccountForYouSource = {
   },
 };
 
+// ── Member For-you source (#7920) ────────────────────────────────────────────
+
+const pieceNeedsClient: AccountForYouSource = {
+  id: "piece-needs-client",
+  async load(ctx) {
+    const { locale, t } = ctx;
+    return (await loadPieces(ctx))
+      .filter((p) => p.needsClient)
+      .map((p) => ({
+        id: `piece:${p.id}`,
+        type: { id: "piece", label: t("pieces.type"), tone: "needs-you" },
+        title: p.title,
+        // The read carries no time the piece began waiting — its last update.
+        time: { kind: "at", at: p.updatedAt },
+        action: {
+          kind: "open",
+          href: localeHref(locale, `/account/inbox/piece/${encodeURIComponent(p.id)}`),
+        },
+        dismissible: true,
+      }));
+  },
+};
+
 // ── Contributions ─────────────────────────────────────────────────────────────
 
 /** Inbox item kinds, in load order. A module appends its own. */
-export const accountInboxKinds: AccountInboxKind[] = [result, purchase];
+export const accountInboxKinds: AccountInboxKind[] = [result, purchase, piece, message];
 
 /** User-settings sections a module adds after the base ones. None in the base area. */
 export const accountSettingsSections: AccountSettingsSection[] = [];
@@ -218,4 +346,5 @@ export const accountSettingsSections: AccountSettingsSection[] = [];
 export const accountForYouSources: AccountForYouSource[] = [
   emailUnverified,
   paymentDue,
+  pieceNeedsClient,
 ];

package/templates/apps/web/lib/api-origin.generated.ts

@@ -0,0 +1,11 @@
+// api-origin.generated.ts — the browser-facing API origin this site's server reads.
+//
+// GENERATED by create-ailk for this site's topology (#7874). Do not edit:
+// every scaffold rewrites it. A hub reads NEXT_PUBLIC_AILK_API_URL as a
+// fallback API origin; a spoke (`--topology spoke`) has no browser-facing
+// API origin — its hub origin is server-only (AILK_API_URL) — so its render
+// reads no environment variable.
+
+export function browserApiOrigin(): string | undefined {
+  return process.env.NEXT_PUBLIC_AILK_API_URL;
+}