@teamscala/service-boot 0.23.506 → 0.23.507

package/package.json

@@ -1131,5 +1131,5 @@
   "repository": "https://github.com/teamgbg/service-boot",
   "sideEffects": false,
   "type": "module",
-  "version": "0.23.506"
+  "version": "0.23.507"
 }

package/src/bind-page-handler.ts

@@ -22,10 +22,7 @@
 		// wave-parallel loader, brotli) is the sanctioned path; re-adding shared-cache headers needs a fresh operator ruling.
 
 import { getAppLogger } from "@teamscala/logger/app-loggers";
-import {
-	withGateEntryClears,
-	takeGateEntryClears,
-} from "./content-gate/gate-entry-clears.ts";
+import { withGateEntryClears } from "./content-gate/gate-entry-clears.ts";
 import type { Context } from "hono";
 import { readHtmlTemplate } from "./read-html-template.ts";
 import {
@@ -127,7 +124,7 @@ export async function bindPageHandler(
 
 		const nonce = c.get("nonce") as string | undefined;
 
-		const resp = await withGateEntryClears(async () =>
+		const { result: resp, clears: gateEntryClears } = await withGateEntryClears(async () =>
 			handler(c.req.raw, {
 				userId,
 				orgId,
@@ -142,7 +139,7 @@ export async function bindPageHandler(
 		// clears it here, so the next load (a refresh) is unauthorized and shows
 		// the gate again. Without this the marker would outlive the view that
 		// used it and every load would skip the gate.
-		for (const name of takeGateEntryClears()) {
+		for (const name of gateEntryClears) {
 			headers.append(
 				"Set-Cookie",
 				`${name}=; Path=/; HttpOnly; Secure; SameSite=Lax; Max-Age=0`,

package/src/content-gate/gate-entry-clears.ts

@@ -10,6 +10,12 @@
  * gate. The gate writes the name here; bindPageHandler — which owns the page
  * Response — drains it into Set-Cookie, so the marker lives exactly one view.
  *
+ * THE CLEARS COME BACK AS THE CALL'S RETURN VALUE, never from a post-hoc
+ * read: the store only exists inside the run() scope, so a reader called after
+ * the awaited call has already left it and would see an empty list — which is
+ * exactly how the first version of this file shipped a marker that was never
+ * cleared (measured live 2026-09-14: the cookie survived the render).
+ *
  * AsyncLocalStorage rather than a module-level map: request-scoped by
  * construction, no accumulated process state that a restart would silently
  * reset (in-memory-state-is-not-durable).
@@ -18,8 +24,12 @@ import { AsyncLocalStorage } from "node:async_hooks";
 
 const clears = new AsyncLocalStorage<string[]>();
 
-export async function withGateEntryClears<T>(fn: () => Promise<T>): Promise<T> {
-	return clears.run([], fn);
+export async function withGateEntryClears<T>(
+	fn: () => Promise<T>,
+): Promise<{ result: T; clears: string[] }> {
+	const list: string[] = [];
+	const result = await clears.run(list, fn);
+	return { result, clears: [...list] };
 }
 
 export function recordGateEntryClear(cookieName: string): void {
@@ -29,10 +39,3 @@ export function recordGateEntryClear(cookieName: string): void {
 	// throwing would make an otherwise valid direct invocation a failure.
 	if (list && !list.includes(cookieName)) list.push(cookieName);
 }
-
-export function takeGateEntryClears(): string[] {
-	const list = clears.getStore() ?? [];
-	const out = [...list];
-	list.length = 0;
-	return out;
-}

package/src/content-gate/gate-entry-marker.test.ts

@@ -7,8 +7,12 @@
  * entryCookieName must behave exactly as before — a valid token authorizes on
  * any load and nothing is recorded for clearing (condition 1: every non-opting
  * service unchanged). An opting gate authorizes ONLY the request that carries
- * the marker (the identity submit's own redirect) and records the marker so the
- * page Response clears it — one view, then the gate is presented again.
+ * the marker (the identity submit's own redirect) and returns the marker name
+ * so the page Response clears it — one view, then the gate is presented again.
+ *
+ * The clears are asserted from the CALL'S RETURN VALUE: the store lives only
+ * inside the run() scope, and the first shipped version read it afterwards,
+ * saw nothing, and left the marker in the browser (measured live 2026-09-14).
  *
  * Operator ruling 2026-09-14 (refresh must return to the identity gate),
  * mechanism measured live: the quiz_token cookie alone was the carrier that
@@ -17,10 +21,7 @@
 import { describe, expect, test } from "bun:test";
 import type { ContentGateConfig } from "./config-types.ts";
 import { runContentGate } from "./gate.ts";
-import {
-	takeGateEntryClears,
-	withGateEntryClears,
-} from "./gate-entry-clears.ts";
+import { withGateEntryClears } from "./gate-entry-clears.ts";
 
 function makeConfig(entryCookieName?: string) {
 	const calls = { authorized: 0, unauthorized: 0 };
@@ -41,30 +42,30 @@ function makeConfig(entryCookieName?: string) {
 }
 
 describe("gate entry marker is opt-in and one-view", () => {
-	test("non-opting gate: a valid token authorizes on any load, nothing recorded — behaviour unchanged", async () => {
+	test("non-opting gate: a valid token authorizes on any load, nothing cleared — behaviour unchanged", async () => {
 		const { cfg, calls } = makeConfig();
-		await withGateEntryClears(async () => {
+		const { clears } = await withGateEntryClears(async () => {
 			const out = await runContentGate({}, "quiz_token=good", Date.now(), cfg);
 			expect(out.authorized).toBe(true);
 			expect(calls.authorized).toBe(1);
-			expect(takeGateEntryClears()).toEqual([]);
 		});
+		expect(clears).toEqual([]);
 	});
 
 	test("opting gate: token WITHOUT the marker is unauthorized — a refresh shows the gate", async () => {
 		const { cfg, calls } = makeConfig("quiz_token_entered");
-		await withGateEntryClears(async () => {
+		const { clears } = await withGateEntryClears(async () => {
 			const out = await runContentGate({}, "quiz_token=good", Date.now(), cfg);
 			expect(out.authorized).toBe(false);
 			expect(calls.unauthorized).toBe(1);
 			expect(calls.authorized).toBe(0);
-			expect(takeGateEntryClears()).toEqual([]);
 		});
+		expect(clears).toEqual([]);
 	});
 
-	test("opting gate: token + marker authorizes and records the marker for clearing, exactly once", async () => {
+	test("opting gate: token + marker authorizes and RETURNS the marker for clearing — one view", async () => {
 		const { cfg, calls } = makeConfig("quiz_token_entered");
-		await withGateEntryClears(async () => {
+		const { clears } = await withGateEntryClears(async () => {
 			const out = await runContentGate(
 				{},
 				"quiz_token=good; quiz_token_entered=1",
@@ -73,15 +74,13 @@ describe("gate entry marker is opt-in and one-view", () => {
 			);
 			expect(out.authorized).toBe(true);
 			expect(calls.authorized).toBe(1);
-			expect(takeGateEntryClears()).toEqual(["quiz_token_entered"]);
-			// drained: the next load must not re-clear
-			expect(takeGateEntryClears()).toEqual([]);
 		});
+		expect(clears).toEqual(["quiz_token_entered"]);
 	});
 
-	test("opting gate: marker present but token invalid stays unauthorized and records nothing", async () => {
+	test("opting gate: marker present but token invalid stays unauthorized and clears nothing", async () => {
 		const { cfg, calls } = makeConfig("quiz_token_entered");
-		await withGateEntryClears(async () => {
+		const { clears } = await withGateEntryClears(async () => {
 			const out = await runContentGate(
 				{},
 				"quiz_token=bad; quiz_token_entered=1",
@@ -90,8 +89,18 @@ describe("gate entry marker is opt-in and one-view", () => {
 			);
 			expect(out.authorized).toBe(false);
 			expect(calls.unauthorized).toBe(1);
-			expect(takeGateEntryClears()).toEqual([]);
 		});
+		expect(clears).toEqual([]);
+	});
+
+	test("two gates in one request each report their own marker, drained once", async () => {
+		const first = makeConfig("gate_a_entered");
+		const second = makeConfig("gate_b_entered");
+		const { clears } = await withGateEntryClears(async () => {
+			await runContentGate({}, "quiz_token=good; gate_a_entered=1", Date.now(), first.cfg);
+			await runContentGate({}, "quiz_token=good; gate_b_entered=1", Date.now(), second.cfg);
+		});
+		expect(clears).toEqual(["gate_a_entered", "gate_b_entered"]);
 	});
 
 	test("the quiz gate and its access endpoint both opt in on the same marker name", async () => {