stratal 0.0.27 → 0.1.0

package/dist/response-cache/index.mjs

@@ -0,0 +1,511 @@
+import { l as Singleton, p as inject } from "../di-DQ3xbjgf.mjs";
+import { n as __decorateParam, t as __decorate } from "../decorate-C79yt3Wt.mjs";
+import { LOGGER_TOKENS } from "../logger/index.mjs";
+import { n as Module } from "../module.decorator-CYbrOlX9.mjs";
+import { n as markGatewayMode, t as isGatewayMode } from "../gateway-mode-0rUaeW3g.mjs";
+import { a as unkeyedVary, n as setResponseHeaders, o as shouldLoopback } from "../response-headers-BqA57S_X.mjs";
+import { n as InvalidCacheTagError, r as ResponseCacheConfigError, t as CachePurgeError } from "../response-cache.error-B4D0zy9W.mjs";
+import { a as PurgesCache, c as getCacheable, d as resolveCachedEntrypoint, i as cachingUnavailableReason, l as RESPONSE_CACHE_TOKENS, n as assertNoGatewayOptions, o as getPurgesCache, r as assertValidGatewayEntrypoint, s as Cacheable, t as bindRouteCache, u as createLoopbackPurgeTarget } from "../route-cache-binding-CrLh8tB6.mjs";
+//#region src/response-cache/tag-template.ts
+/** Cloudflare's per-tag ceiling. Longer tags are dropped silently. */
+const MAX_TAG_BYTES = 1024;
+/** Hoisted: one encoder for the process, not one per tag per request. */
+const TEXT_ENCODER = new TextEncoder();
+/**
+* Printable ASCII (`0x21`–`0x7E`) — which already excludes space, every C0
+* control (`\t`, `\r`, `\n`, `\v`, `\f`), `DEL`, and all non-ASCII, so header
+* splitting via CR/LF is impossible — **minus** the two characters that carry
+* structural meaning inside the header this value is written into:
+*
+* - `,` (`0x2C`) delimits the `Cache-Tag` list. `CacheabilityService.apply`
+*   joins tags with `','`, so a rendered tag containing a comma is not one tag
+*   — it becomes two, neither of which is the tag the author named, and every
+*   later purge for the intended tag misses forever. On the `@PurgesCache`
+*   path it is worse: rendered tags are handed straight to `ctx.cache.purge()`,
+*   so a comma arriving in request input (`?t=a,b`) purges tags the author
+*   never wrote — an arbitrary cache-flush primitive driven by the request.
+* - `"` (`0x22`) opens a quoted-string in an RFC 9110 §5.6.1 comma-delimited
+*   list. An unbalanced quote makes a strict parser stop treating the
+*   following commas as delimiters, smuggling list structure the same way.
+*
+* `\` is deliberately still allowed: it only has meaning *inside* a
+* quoted-string, and `"` can no longer appear to open one.
+*/
+const VALID_TAG = /^[\x21\x23-\x2B\x2D-\x7E]+$/;
+const PLACEHOLDER = /\{([A-Za-z]+)\.([^}]+)\}/g;
+const SCOPES = [
+	"param",
+	"query",
+	"body",
+	"data",
+	"partition"
+];
+/**
+* Render `Cache-Tag` templates against the current request's scopes.
+*
+* A single `.*` suffix expands an array into one tag per element. Missing
+* values throw rather than rendering a broken tag: Cloudflare drops invalid
+* tags without any signal, so a silently-wrong tag means a purge that misses
+* forever.
+*/
+function renderTags(templates, scopes) {
+	const out = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const template of templates) for (const tag of renderOne(template, scopes)) {
+		assertValidTag(tag);
+		if (!seen.has(tag)) {
+			seen.add(tag);
+			out.push(tag);
+		}
+	}
+	return out;
+}
+/** Throw unless `tag` is something Cloudflare will actually store. */
+function assertValidTag(tag) {
+	if (tag.length === 0) throw new InvalidCacheTagError(tag, "tag is empty");
+	if (TEXT_ENCODER.encode(tag).length > MAX_TAG_BYTES) throw new InvalidCacheTagError(tag, `exceeds ${MAX_TAG_BYTES} bytes`);
+	if (!VALID_TAG.test(tag)) throw new InvalidCacheTagError(tag, "must be printable ASCII with no space, comma, or double quote — a comma would split this into two `Cache-Tag` entries, neither of which is the tag that was declared");
+}
+/** Render one template, expanding at most one `.*` fan-out. */
+function renderOne(template, scopes) {
+	const matches = [...template.matchAll(PLACEHOLDER)];
+	const fanOuts = matches.filter((m) => m[2].endsWith(".*"));
+	if (fanOuts.length > 1) throw new InvalidCacheTagError(template, "only one `.*` fan-out is supported per tag");
+	if (fanOuts.length === 0) return [substitute(matches, scopes, void 0, template)];
+	const [fan] = fanOuts;
+	const path = fan[2].slice(0, -2);
+	const value = lookup(fan[1], path, scopes, template);
+	if (!Array.isArray(value)) throw new InvalidCacheTagError(template, `\`${fan[1]}.${path}\` is not an array`);
+	return value.map((item) => substitute(matches, scopes, {
+		placeholder: fan[0],
+		item
+	}, template));
+}
+/** Replace every placeholder with its resolved value, left to right. */
+function substitute(matches, scopes, fan, template) {
+	const parts = [];
+	let cursor = 0;
+	for (const match of matches) {
+		const [placeholder, scope, path] = match;
+		const index = match.index ?? 0;
+		parts.push(template.slice(cursor, index));
+		const value = fan && placeholder === fan.placeholder ? fan.item : lookup(scope, path, scopes, template);
+		parts.push(stringify(value, template));
+		cursor = index + placeholder.length;
+	}
+	parts.push(template.slice(cursor));
+	return parts.join("");
+}
+/** Walk `scope.path`, throwing on an unknown scope or a missing value. */
+function lookup(scope, path, scopes, template) {
+	if (!SCOPES.includes(scope)) throw new InvalidCacheTagError(template, `unknown scope "${scope}" (expected one of ${SCOPES.join(", ")})`);
+	let current = scopes[scope];
+	for (const segment of path.split(".")) {
+		if (current === null || current === void 0 || typeof current !== "object") throw new InvalidCacheTagError(template, `\`${scope}.${path}\` is not present on this request`);
+		current = current[segment];
+	}
+	if (current === null || current === void 0) throw new InvalidCacheTagError(template, `\`${scope}.${path}\` is not present on this request`);
+	return current;
+}
+/** Coerce an interpolated value to its tag text. */
+function stringify(value, template) {
+	if (typeof value === "string") return value;
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	throw new InvalidCacheTagError(template, `interpolated value has unsupported type "${typeof value}"`);
+}
+//#endregion
+//#region src/response-cache/services/cacheability.service.ts
+/** What fail-closed emits. Cloudflare treats this as BYPASS. */
+const NO_STORE = "private, no-store";
+let CacheabilityService = class CacheabilityService {
+	logger;
+	options;
+	constructor(logger, options) {
+		this.logger = logger;
+		this.options = options;
+	}
+	apply(response, resolved, scopes, signals) {
+		const vary = this.mergeVary(response, [...resolved.vary, ...signals.inertia?.varyHeaders ?? []]);
+		const reason = this.rejectionReason(response, signals, vary);
+		if (reason) {
+			this.logger.warn("[stratal:response-cache] Response not cached", { reason });
+			return this.withHeaders(response, { "Cache-Control": NO_STORE });
+		}
+		const headers = {
+			"Cache-Control": this.browserCacheControl(resolved),
+			"CDN-Cache-Control": this.sharedCacheControl(resolved)
+		};
+		let tags;
+		try {
+			tags = renderTags(resolved.tags, scopes);
+		} catch (error) {
+			this.logger.error("[stratal:response-cache] Invalid cache tag; not caching", { error });
+			return this.withHeaders(response, { "Cache-Control": NO_STORE });
+		}
+		if (tags.length > 0) headers["Cache-Tag"] = tags.join(",");
+		if (vary) headers.Vary = vary;
+		return this.withHeaders(response, headers);
+	}
+	/** The first condition that makes this response unsafe to cache, if any. */
+	rejectionReason(response, signals, vary) {
+		if (response.headers.has("Set-Cookie")) return "set-cookie";
+		if (response.status < 200 || response.status > 299) return "status";
+		if (!signals.partitionsResolved) return "partition-unresolved";
+		const inertia = signals.inertia;
+		if (inertia?.hasFlash) return "inertia-flash";
+		if (inertia?.hasOnceProps) return "inertia-once";
+		if (inertia?.isPartial && inertia.varyHeaders.length === 0) return "inertia-partial-unkeyed";
+		const gateway = this.options.gateway;
+		const unkeyed = gateway ? unkeyedVary(vary, gateway.keyBy) : [];
+		if (unkeyed.length > 0) {
+			this.logger.warn(`[stratal:response-cache] Response varies on ${unkeyed.join(", ")}, which is not in the cache key, so it is not cached. Add those names to ResponseCacheModule.forRoot({ gateway: { keyBy: [...] } }) — for an Inertia app, \`INERTIA_VARY_HEADERS\` from @stratal/inertia.`, { vary: unkeyed });
+			return "vary-unkeyed";
+		}
+		return null;
+	}
+	/**
+	* What a PRIVATE cache — a visitor's browser — may do with the response.
+	*
+	* A browser copy is the one this feature cannot reach: `Cache-Tag` and
+	* `ctx.cache.purge()` retire the shared copy, and nothing retires that one.
+	* So `browserTtl` is what a route says it is willing to have held without
+	* being askable, and it defaults to `ttl` — the same lifetime the shared
+	* cache was already given.
+	*
+	* `stale-while-revalidate` is emitted here as well as on the shared header,
+	* and it is what makes a short `browserTtl` cheap rather than punishing: the
+	* browser paints from the copy it has instead of waiting on the network, and
+	* fetches the replacement behind that. A route that must be retractable sets
+	* `browserTtl: 0` with a stale window, and converges on the next navigation
+	* rather than holding a withdrawn response for the whole `ttl`.
+	*
+	* `must-revalidate` only where there is no stale window to protect: it
+	* forbids serving stale at all, which is the opposite of what `swr` asks
+	* for, so emitting both would leave the pair contradicting each other.
+	*/
+	browserCacheControl(resolved) {
+		const parts = ["public", `max-age=${resolved.browserTtl}`];
+		if (resolved.swr !== void 0) parts.push(`stale-while-revalidate=${resolved.swr}`);
+		else if (resolved.browserTtl === 0) parts.push("must-revalidate");
+		return parts.join(", ");
+	}
+	/** The lifetime, for the cache that can be purged. */
+	sharedCacheControl(resolved) {
+		const parts = ["public", `max-age=${resolved.ttl}`];
+		if (resolved.swr !== void 0) parts.push(`stale-while-revalidate=${resolved.swr}`);
+		return parts.join(", ");
+	}
+	/** Union the declared Vary names with whatever the response already set. */
+	mergeVary(response, declared) {
+		const existing = (response.headers.get("Vary") ?? "").split(",").map((v) => v.trim()).filter(Boolean);
+		const merged = [.../* @__PURE__ */ new Set([...existing, ...declared])];
+		return merged.length > 0 ? merged.join(", ") : null;
+	}
+	/**
+	* Overlay headers onto the response, mutating in place when the header
+	* list is writable — see `setResponseHeaders` for why that's the common
+	* case and safe. `Cache-Tag` and `CDN-Cache-Control` are explicitly deleted
+	* (not just omitted) when degrading to `no-store`, so neither a stale tag
+	* nor a lifetime from a differently-decided response lingers. The second
+	* matters most: Cloudflare reads `CDN-Cache-Control` in preference to
+	* `Cache-Control`, so one left behind would cache a response this just
+	* refused to cache.
+	*/
+	withHeaders(response, headers) {
+		const toSet = { ...headers };
+		if (headers["Cache-Control"] === NO_STORE) {
+			toSet["Cache-Tag"] = null;
+			toSet["CDN-Cache-Control"] = null;
+		}
+		return setResponseHeaders(response, toSet);
+	}
+};
+CacheabilityService = __decorate([
+	Singleton(RESPONSE_CACHE_TOKENS.CacheabilityService),
+	__decorateParam(0, inject(LOGGER_TOKENS.LoggerService)),
+	__decorateParam(1, inject(RESPONSE_CACHE_TOKENS.Options))
+], CacheabilityService);
+//#endregion
+//#region src/response-cache/services/gateway-primer.service.ts
+let GatewayPrimerService = class GatewayPrimerService {
+	options;
+	logger;
+	constructor(options, logger) {
+		this.options = options;
+		this.logger = logger;
+	}
+	get hasPrimers() {
+		return (this.options.primers?.length ?? 0) > 0;
+	}
+	/**
+	* Run every primer in registration order.
+	*
+	* @returns `true` when the whole chain ran to completion, `false` when a
+	*   primer short-circuited.
+	*
+	* `Middleware.handle` may return a `Response` to short-circuit its chain — an
+	* auth middleware rejecting a request, for example. In the gateway that
+	* `Response` is **not** the answer to send: primers run only to populate the
+	* request container before partition resolution, and the real middleware
+	* chain still runs inside the app, where the same middleware will produce the
+	* same rejection through the application's own pipeline (exception handler,
+	* logging, Inertia error shaping). Answering from the gateway would make it a
+	* second, partially-run response pipeline whose output is assembled by a
+	* *subset* of the app's middleware.
+	*
+	* So the `Response` is dropped — but not silently. A short-circuit means the
+	* container was never fully primed, so partition resolution cannot be
+	* trusted; the caller must fail closed and run the request inline instead of
+	* caching it.
+	*/
+	async prime(ctx) {
+		const primers = this.options.primers ?? [];
+		const container = ctx.getContainer();
+		for (const Primer of primers) {
+			const result = await container.resolve(Primer).handle(ctx, async () => {});
+			if (result instanceof Response) {
+				this.logger.debug("[stratal:response-cache] Primer short-circuited; not caching", {
+					primer: Primer.name,
+					status: result.status
+				});
+				return false;
+			}
+		}
+		return true;
+	}
+};
+GatewayPrimerService = __decorate([
+	Singleton(RESPONSE_CACHE_TOKENS.GatewayPrimerService),
+	__decorateParam(0, inject(RESPONSE_CACHE_TOKENS.Options)),
+	__decorateParam(1, inject(LOGGER_TOKENS.LoggerService))
+], GatewayPrimerService);
+//#endregion
+//#region src/response-cache/services/gateway-route-table.ts
+let GatewayRouteTable = class GatewayRouteTable {
+	entries = /* @__PURE__ */ new Map();
+	/**
+	* The consumer's `export const <name> = cachedEntrypoint(stratal)`, from
+	* `ResponseCacheModule.forRoot({ gateway: { entrypoint } })`.
+	*
+	* `undefined` means no gateway is configured, which is also the condition
+	* under which `bindRouteCache` refuses a non-empty `partitionBy` — so an
+	* unconfigured table is always an empty one.
+	*/
+	entrypoint;
+	/**
+	* `gateway.keyBy` — the request headers whose values join the cache key.
+	*
+	* Carried here rather than resolved per request because the dispatch
+	* middleware already memoises this table, so reading it costs a property
+	* access on the hot path instead of a container lookup.
+	*/
+	keyBy = [];
+	/** Set by `RouteRegistrationService.configure()`, before any request. */
+	configure(entrypoint, keyBy = []) {
+		this.entrypoint = entrypoint;
+		this.keyBy = keyBy;
+	}
+	/** True when no route in this app declares a partition. */
+	get isEmpty() {
+		return this.entries.size === 0;
+	}
+	/** Number of recorded routes. Test/diagnostic affordance. */
+	get size() {
+		return this.entries.size;
+	}
+	/**
+	* Record one registered route.
+	*
+	* `method` is the Hono-registered method; `path` is the pattern the route
+	* was registered under (already expanded for versioning and locale
+	* variants, so each variant gets its own entry).
+	*/
+	record(method, path, partitionBy) {
+		if (partitionBy.length === 0) return;
+		this.entries.set(`${method.toUpperCase()} ${path}`, { partitionBy });
+	}
+	/** The entry for a matched route pattern, or `undefined` to run inline. */
+	lookup(method, path) {
+		return this.entries.get(`${method.toUpperCase()} ${path}`);
+	}
+};
+GatewayRouteTable = __decorate([Singleton(RESPONSE_CACHE_TOKENS.GatewayRouteTable)], GatewayRouteTable);
+//#endregion
+//#region src/response-cache/services/partition-resolver.service.ts
+let PartitionResolverService = class PartitionResolverService {
+	options;
+	logger;
+	constructor(options, logger) {
+		this.options = options;
+		this.logger = logger;
+	}
+	/** Throw at boot if a route names a partition with no registered resolver. */
+	assertKnown(names, where) {
+		const known = Object.keys(this.options.partitions ?? {});
+		for (const name of names) if (!known.includes(name)) throw new ResponseCacheConfigError(`${where}: unknown partition "${name}". Register it via ResponseCacheModule.forRoot({ partitions: { ${name}: (ctx) => ... } }). Known partitions: ${known.length > 0 ? known.join(", ") : "(none)"}.`);
+	}
+	/**
+	* Partition names seen so far, split by whether they have ever resolved.
+	*
+	* A resolver that fails is ordinary traffic — an anonymous visitor to a
+	* per-user route — so the per-request signal stays at `debug`. But a
+	* partition that has *never* resolved is a configuration mistake, not
+	* traffic: the usual cause is `partitions: { user: (ctx) => ctx.user().id }`
+	* configured without `primers: AUTH_GATEWAY_PRIMERS`, so `ctx.user()` throws
+	* on every request and the route is silently never cached. Warned once per
+	* name, so that diagnosis is available without making normal misses noisy.
+	*/
+	warnedUnresolved = /* @__PURE__ */ new Set();
+	everResolved = /* @__PURE__ */ new Set();
+	noteUnresolved(name) {
+		if (this.everResolved.has(name) || this.warnedUnresolved.has(name)) return;
+		this.warnedUnresolved.add(name);
+		this.logger.warn(`[stratal:response-cache] Partition "${name}" has never resolved; routes using it are not being cached. If its resolver calls \`ctx.user()\` or reads the request container, the gateway needs \`primers\` (e.g. \`AUTH_GATEWAY_PRIMERS\` from @stratal/framework) to populate that context before resolution runs.`, { partition: name });
+	}
+	async resolve(ctx, names) {
+		if (names.length === 0) return {
+			props: {},
+			resolved: true
+		};
+		const partitions = this.options.partitions ?? {};
+		const props = {};
+		for (const name of names) {
+			const resolver = partitions[name];
+			if (!resolver) return {
+				props: {},
+				resolved: false
+			};
+			let value;
+			try {
+				value = await resolver(ctx);
+			} catch (error) {
+				this.logger.debug("[stratal:response-cache] Partition resolver threw; not caching", {
+					partition: name,
+					error
+				});
+				this.noteUnresolved(name);
+				return {
+					props: {},
+					resolved: false
+				};
+			}
+			if (value === null || value === void 0) {
+				this.logger.debug("[stratal:response-cache] Partition unresolved; not caching", { partition: name });
+				this.noteUnresolved(name);
+				return {
+					props: {},
+					resolved: false
+				};
+			}
+			this.everResolved.add(name);
+			props[name] = value;
+		}
+		return {
+			props,
+			resolved: true
+		};
+	}
+};
+PartitionResolverService = __decorate([
+	Singleton(RESPONSE_CACHE_TOKENS.PartitionResolverService),
+	__decorateParam(0, inject(RESPONSE_CACHE_TOKENS.Options)),
+	__decorateParam(1, inject(LOGGER_TOKENS.LoggerService))
+], PartitionResolverService);
+//#endregion
+//#region src/response-cache/services/response-cache.service.ts
+let ResponseCacheService = class ResponseCacheService {
+	logger;
+	constructor(logger) {
+		this.logger = logger;
+	}
+	/** Render a `@PurgesCache` declaration against this request's scopes. */
+	buildPurgeSpec(options, scopes) {
+		if (options.purgeEverything) return { purgeEverything: true };
+		const spec = {};
+		if (options.tags?.length) spec.tags = renderTags(options.tags, scopes);
+		if (options.pathPrefixes?.length) spec.pathPrefixes = [...options.pathPrefixes];
+		return spec;
+	}
+	/**
+	* Issue a purge and wait for it.
+	*
+	* Deliberately not deferred through `waitUntil`: a client that re-reads
+	* immediately after its own write must not be served the pre-write response.
+	*
+	* @throws {CachePurgeError} The mutation has already committed at this point,
+	*   so failing loudly is the lesser evil against a cache that is silently
+	*   inconsistent with the database.
+	*/
+	async purge(spec, cache) {
+		try {
+			const result = await cache.purge(spec);
+			if (result && !result.success) {
+				this.logger.error("[stratal:response-cache] Purge reported failure", { spec });
+				throw new CachePurgeError(`the runtime reported failure for ${JSON.stringify(spec)}`);
+			}
+		} catch (error) {
+			if (error instanceof CachePurgeError) throw error;
+			this.logger.error("[stratal:response-cache] Purge threw", {
+				spec,
+				error: error instanceof Error ? error.message : String(error)
+			});
+			throw new CachePurgeError(error instanceof Error ? error.message : String(error));
+		}
+	}
+};
+ResponseCacheService = __decorate([Singleton(RESPONSE_CACHE_TOKENS.ResponseCacheService), __decorateParam(0, inject(LOGGER_TOKENS.LoggerService))], ResponseCacheService);
+//#endregion
+//#region src/response-cache/response-cache.module.ts
+var _ResponseCacheModule;
+let ResponseCacheModule = _ResponseCacheModule = class ResponseCacheModule {
+	static forRoot(options = {}) {
+		assertNoGatewayOptions(options);
+		return {
+			module: _ResponseCacheModule,
+			providers: [{
+				provide: RESPONSE_CACHE_TOKENS.Options,
+				useValue: options
+			}]
+		};
+	}
+	static forRootAsync(options) {
+		return {
+			module: _ResponseCacheModule,
+			providers: [{
+				provide: RESPONSE_CACHE_TOKENS.Options,
+				useFactory: (...deps) => {
+					const resolved = options.useFactory(...deps);
+					if (!(resolved instanceof Promise)) assertNoGatewayOptions(resolved);
+					return resolved;
+				},
+				inject: options.inject ?? []
+			}]
+		};
+	}
+};
+ResponseCacheModule = _ResponseCacheModule = __decorate([Module({ providers: [
+	{
+		provide: RESPONSE_CACHE_TOKENS.CacheabilityService,
+		useClass: CacheabilityService
+	},
+	{
+		provide: RESPONSE_CACHE_TOKENS.PartitionResolverService,
+		useClass: PartitionResolverService
+	},
+	{
+		provide: RESPONSE_CACHE_TOKENS.GatewayPrimerService,
+		useClass: GatewayPrimerService
+	},
+	{
+		provide: RESPONSE_CACHE_TOKENS.ResponseCacheService,
+		useClass: ResponseCacheService
+	},
+	{
+		provide: RESPONSE_CACHE_TOKENS.GatewayRouteTable,
+		useClass: GatewayRouteTable
+	}
+] })], ResponseCacheModule);
+//#endregion
+export { CachePurgeError, Cacheable, GatewayRouteTable, InvalidCacheTagError, PurgesCache, RESPONSE_CACHE_TOKENS, ResponseCacheConfigError, ResponseCacheModule, assertValidGatewayEntrypoint, bindRouteCache, cachingUnavailableReason, createLoopbackPurgeTarget, getCacheable, getPurgesCache, isGatewayMode, markGatewayMode, resolveCachedEntrypoint, shouldLoopback };
+
+//# sourceMappingURL=index.mjs.map

package/dist/response-cache/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../src/response-cache/tag-template.ts","../../src/response-cache/services/cacheability.service.ts","../../src/response-cache/services/gateway-primer.service.ts","../../src/response-cache/services/gateway-route-table.ts","../../src/response-cache/services/partition-resolver.service.ts","../../src/response-cache/services/response-cache.service.ts","../../src/response-cache/response-cache.module.ts"],"sourcesContent":["import { InvalidCacheTagError } from './errors'\n\n/**\n * Values available to `{scope.path}` placeholders when rendering tags.\n *\n * `body` is never populated by the HTTP router — `RouteRegistrationService\n * .buildTagScopes` always sets it `undefined`, and route registration now\n * rejects any `{body.*}` tag at boot (`bindRouteCache`) precisely because\n * nothing can ever fill it in on the request path. It stays part of this\n * type — rather than being dropped — because `renderTags` is a general\n * template compiler exercised directly in its own unit tests with hand-built\n * scopes (including `body`); those tests are about the compiler accepting\n * all four scopes correctly, independent of what any one caller can supply.\n */\nexport interface TagScopes {\n  param: Record<string, string>\n  query: Record<string, string>\n  body: unknown\n  data: unknown\n  /**\n   * The partition values this request resolved, keyed by partition name.\n   *\n   * The only scope guaranteed present on every variant of a response. `data`\n   * is the resolved payload, and an Inertia partial reload carries only the\n   * props it asked for — so `{data.auth.user.id}` renders on the document and\n   * throws on the partial, which fails that variant closed and leaves exactly\n   * the deferred work uncached. A partition is in the cache key by\n   * construction, so `{partition.user}` renders identically on both.\n   */\n  partition: Record<string, string>\n}\n\n/** Cloudflare's per-tag ceiling. Longer tags are dropped silently. */\nconst MAX_TAG_BYTES = 1024\n/** Hoisted: one encoder for the process, not one per tag per request. */\nconst TEXT_ENCODER = new TextEncoder()\n/**\n * Printable ASCII (`0x21`–`0x7E`) — which already excludes space, every C0\n * control (`\\t`, `\\r`, `\\n`, `\\v`, `\\f`), `DEL`, and all non-ASCII, so header\n * splitting via CR/LF is impossible — **minus** the two characters that carry\n * structural meaning inside the header this value is written into:\n *\n * - `,` (`0x2C`) delimits the `Cache-Tag` list. `CacheabilityService.apply`\n *   joins tags with `','`, so a rendered tag containing a comma is not one tag\n *   — it becomes two, neither of which is the tag the author named, and every\n *   later purge for the intended tag misses forever. On the `@PurgesCache`\n *   path it is worse: rendered tags are handed straight to `ctx.cache.purge()`,\n *   so a comma arriving in request input (`?t=a,b`) purges tags the author\n *   never wrote — an arbitrary cache-flush primitive driven by the request.\n * - `\"` (`0x22`) opens a quoted-string in an RFC 9110 §5.6.1 comma-delimited\n *   list. An unbalanced quote makes a strict parser stop treating the\n *   following commas as delimiters, smuggling list structure the same way.\n *\n * `\\` is deliberately still allowed: it only has meaning *inside* a\n * quoted-string, and `\"` can no longer appear to open one.\n */\nconst VALID_TAG = /^[\\x21\\x23-\\x2B\\x2D-\\x7E]+$/\nconst PLACEHOLDER = /\\{([A-Za-z]+)\\.([^}]+)\\}/g\nconst SCOPES = ['param', 'query', 'body', 'data', 'partition'] as const\n\n/**\n * Render `Cache-Tag` templates against the current request's scopes.\n *\n * A single `.*` suffix expands an array into one tag per element. Missing\n * values throw rather than rendering a broken tag: Cloudflare drops invalid\n * tags without any signal, so a silently-wrong tag means a purge that misses\n * forever.\n */\nexport function renderTags(templates: string[], scopes: TagScopes): string[] {\n  const out: string[] = []\n  // A `Set` keeps membership checks O(1) — an `Array.includes` scan here would\n  // make a fan-out template (`{body.ids.*}` over hundreds of ids) quadratic.\n  // The array still carries insertion order for the returned result.\n  const seen = new Set<string>()\n\n  for (const template of templates) {\n    for (const tag of renderOne(template, scopes)) {\n      assertValidTag(tag)\n      if (!seen.has(tag)) {\n        seen.add(tag)\n        out.push(tag)\n      }\n    }\n  }\n\n  return out\n}\n\n/** Throw unless `tag` is something Cloudflare will actually store. */\nexport function assertValidTag(tag: string): void {\n  if (tag.length === 0) {\n    throw new InvalidCacheTagError(tag, 'tag is empty')\n  }\n  if (TEXT_ENCODER.encode(tag).length > MAX_TAG_BYTES) {\n    throw new InvalidCacheTagError(tag, `exceeds ${MAX_TAG_BYTES} bytes`)\n  }\n  if (!VALID_TAG.test(tag)) {\n    throw new InvalidCacheTagError(\n      tag,\n      'must be printable ASCII with no space, comma, or double quote — a comma would split ' +\n        'this into two `Cache-Tag` entries, neither of which is the tag that was declared',\n    )\n  }\n}\n\n/** Render one template, expanding at most one `.*` fan-out. */\nfunction renderOne(template: string, scopes: TagScopes): string[] {\n  const matches = [...template.matchAll(PLACEHOLDER)]\n  const fanOuts = matches.filter((m) => m[2].endsWith('.*'))\n\n  if (fanOuts.length > 1) {\n    throw new InvalidCacheTagError(template, 'only one `.*` fan-out is supported per tag')\n  }\n\n  if (fanOuts.length === 0) {\n    return [substitute(matches, scopes, undefined, template)]\n  }\n\n  const [fan] = fanOuts\n  const path = fan[2].slice(0, -2)\n  const value = lookup(fan[1], path, scopes, template)\n\n  if (!Array.isArray(value)) {\n    throw new InvalidCacheTagError(template, `\\`${fan[1]}.${path}\\` is not an array`)\n  }\n\n  return value.map((item) =>\n    substitute(matches, scopes, { placeholder: fan[0], item }, template),\n  )\n}\n\n/** Replace every placeholder with its resolved value, left to right. */\nfunction substitute(\n  matches: RegExpMatchArray[],\n  scopes: TagScopes,\n  fan: { placeholder: string; item: unknown } | undefined,\n  template: string,\n): string {\n  const parts: string[] = []\n  let cursor = 0\n\n  for (const match of matches) {\n    const [placeholder, scope, path] = match\n    const index = match.index ?? 0\n\n    parts.push(template.slice(cursor, index))\n\n    const value =\n      fan && placeholder === fan.placeholder ? fan.item : lookup(scope, path, scopes, template)\n    parts.push(stringify(value, template))\n\n    cursor = index + placeholder.length\n  }\n\n  parts.push(template.slice(cursor))\n\n  return parts.join('')\n}\n\n/** Walk `scope.path`, throwing on an unknown scope or a missing value. */\nfunction lookup(scope: string, path: string, scopes: TagScopes, template: string): unknown {\n  if (!(SCOPES as readonly string[]).includes(scope)) {\n    throw new InvalidCacheTagError(\n      template,\n      `unknown scope \"${scope}\" (expected one of ${SCOPES.join(', ')})`,\n    )\n  }\n\n  let current: unknown = scopes[scope as keyof TagScopes]\n\n  for (const segment of path.split('.')) {\n    if (current === null || current === undefined || typeof current !== 'object') {\n      throw new InvalidCacheTagError(template, `\\`${scope}.${path}\\` is not present on this request`)\n    }\n    current = (current as Record<string, unknown>)[segment]\n  }\n\n  if (current === null || current === undefined) {\n    throw new InvalidCacheTagError(template, `\\`${scope}.${path}\\` is not present on this request`)\n  }\n\n  return current\n}\n\n/** Coerce an interpolated value to its tag text. */\nfunction stringify(value: unknown, template: string): string {\n  if (typeof value === 'string') return value\n  if (typeof value === 'number' || typeof value === 'boolean') return String(value)\n  throw new InvalidCacheTagError(template, `interpolated value has unsupported type \"${typeof value}\"`)\n}\n","import { inject } from '../../di'\nimport { Singleton } from '../../di/decorators'\nimport { LOGGER_TOKENS, type LoggerService } from '../../logger'\nimport { unkeyedVary } from '../representation'\nimport { RESPONSE_CACHE_TOKENS } from '../response-cache.tokens'\nimport { setResponseHeaders } from '../response-headers'\nimport { renderTags, type TagScopes } from '../tag-template'\nimport type { ResolvedCacheable, ResponseCacheModuleOptions } from '../types'\n\n/** Inertia-specific conditions that make a page unsafe to cache. */\nexport interface InertiaCacheSignals {\n  hasFlash: boolean\n  isPartial: boolean\n  hasOnceProps: boolean\n  /**\n   * Request headers the adapter reports this response is a function of.\n   * Unioned into `Vary`, so a partial reload and the full page at the same URL\n   * are stored as separate variants rather than colliding.\n   *\n   * Required rather than optional: an empty list is what makes a partial reload\n   * fail closed, and an adapter that simply forgot the field would otherwise be\n   * indistinguishable from one declaring the response unkeyed.\n   */\n  varyHeaders: readonly string[]\n}\n\nexport interface CacheabilitySignals {\n  /** False when any declared partition resolver returned null/undefined. */\n  partitionsResolved: boolean\n  inertia?: InertiaCacheSignals\n}\n\n/** What fail-closed emits. Cloudflare treats this as BYPASS. */\nconst NO_STORE = 'private, no-store'\n\n\n/**\n * Decides whether a `@Cacheable` response may actually be cached, and stamps\n * the headers that say so.\n *\n * Everything that is not provably safe becomes `private, no-store`. That\n * matters more than it looks: Workers Caching applies RFC 9111 heuristic\n * freshness, so a response with no `Cache-Control` at all is still cached —\n * `200` for two hours. Silence is not a safe default here.\n */\n@Singleton(RESPONSE_CACHE_TOKENS.CacheabilityService)\nexport class CacheabilityService {\n  constructor(\n    @inject(LOGGER_TOKENS.LoggerService) private readonly logger: LoggerService,\n    @inject(RESPONSE_CACHE_TOKENS.Options) private readonly options: ResponseCacheModuleOptions,\n  ) {}\n\n  apply(response: Response, resolved: ResolvedCacheable, scopes: TagScopes, signals: CacheabilitySignals): Response {\n    // Computed before the decision, because what a response varies on is one of\n    // the things that decides it.\n    const vary = this.mergeVary(response, [...resolved.vary, ...(signals.inertia?.varyHeaders ?? [])])\n\n    const reason = this.rejectionReason(response, signals, vary)\n\n    if (reason) {\n      this.logger.warn('[stratal:response-cache] Response not cached', { reason })\n      return this.withHeaders(response, { 'Cache-Control': NO_STORE })\n    }\n\n    // Two audiences, two headers. `CDN-Cache-Control` is the one Cloudflare\n    // reads in preference to `Cache-Control`, and the one browsers ignore\n    // entirely, so the lifetime lands where it can still be purged and nowhere\n    // else. Keeping them separate is also what lets `swr` survive: expressing\n    // the same split through `s-maxage` would end the stale window, since\n    // Cloudflare stops honouring `stale-while-revalidate` once it is present.\n    const headers: Record<string, string> = {\n      'Cache-Control': this.browserCacheControl(resolved),\n      'CDN-Cache-Control': this.sharedCacheControl(resolved),\n    }\n\n    // Malformed tag templates (e.g., missing scope value) throw InvalidCacheTagError.\n    // Rather than crashing the request, fail closed — a bad tag is an author bug\n    // distinct from ordinary rejections (which are runtime data), and the risk\n    // the throw guarded against was a tag silently vanishing while the response\n    // cached anyway. Here, the response doesn't cache at all.\n    let tags: string[]\n    try {\n      tags = renderTags(resolved.tags, scopes)\n    } catch (error) {\n      this.logger.error('[stratal:response-cache] Invalid cache tag; not caching', { error })\n      return this.withHeaders(response, { 'Cache-Control': NO_STORE })\n    }\n\n    if (tags.length > 0) headers['Cache-Tag'] = tags.join(',')\n\n    if (vary) headers.Vary = vary\n\n    return this.withHeaders(response, headers)\n  }\n\n  /** The first condition that makes this response unsafe to cache, if any. */\n  private rejectionReason(response: Response, signals: CacheabilitySignals, vary: string | null): string | null {\n    if (response.headers.has('Set-Cookie')) return 'set-cookie'\n    if (response.status < 200 || response.status > 299) return 'status'\n    if (!signals.partitionsResolved) return 'partition-unresolved'\n\n    const inertia = signals.inertia\n    if (inertia?.hasFlash) return 'inertia-flash'\n    if (inertia?.hasOnceProps) return 'inertia-once'\n\n    // A partial reload IS cacheable — it is a deterministic function of the URL,\n    // the partition, and the headers naming which props were asked for. What is\n    // not cacheable is one whose adapter did not report those headers: keying it\n    // on the URL alone would make it interchangeable with the full page and with\n    // every other prop set at that URL.\n    if (inertia?.isPartial && inertia.varyHeaders.length === 0) return 'inertia-partial-unkeyed'\n\n    // Anything this response varies on that is not also in the cache key is a\n    // way for two different bodies to share one entry. `Vary` is supposed to\n    // prevent that on its own; measured against Workers Caching on a URL with a\n    // query string, it does not — a variant stored for one header value is\n    // handed to a request sending another. So the key has to carry it, and a\n    // response naming a header the key does not is refused rather than stored\n    // wrong. `gateway.keyBy` is what puts a header into the key.\n    //\n    // Only under a gateway, and that boundary is evidence, not caution: the\n    // failure was measured on the loopback topology, and the loopback is also\n    // the only place a representation CAN reach the key, since `ctx.props` is\n    // set by the forwarding call. Refusing without a gateway would withdraw\n    // caching from apps on a path whose behaviour has not been measured, and\n    // offer them nothing to fix it with.\n    const gateway = this.options.gateway\n    const unkeyed = gateway ? unkeyedVary(vary, gateway.keyBy) : []\n    if (unkeyed.length > 0) {\n      this.logger.warn(\n        `[stratal:response-cache] Response varies on ${unkeyed.join(', ')}, which is not in the ` +\n          'cache key, so it is not cached. Add those names to ' +\n          'ResponseCacheModule.forRoot({ gateway: { keyBy: [...] } }) — for an Inertia app, ' +\n          '`INERTIA_VARY_HEADERS` from @stratal/inertia.',\n        { vary: unkeyed },\n      )\n      return 'vary-unkeyed'\n    }\n\n    return null\n  }\n\n  /**\n   * What a PRIVATE cache — a visitor's browser — may do with the response.\n   *\n   * A browser copy is the one this feature cannot reach: `Cache-Tag` and\n   * `ctx.cache.purge()` retire the shared copy, and nothing retires that one.\n   * So `browserTtl` is what a route says it is willing to have held without\n   * being askable, and it defaults to `ttl` — the same lifetime the shared\n   * cache was already given.\n   *\n   * `stale-while-revalidate` is emitted here as well as on the shared header,\n   * and it is what makes a short `browserTtl` cheap rather than punishing: the\n   * browser paints from the copy it has instead of waiting on the network, and\n   * fetches the replacement behind that. A route that must be retractable sets\n   * `browserTtl: 0` with a stale window, and converges on the next navigation\n   * rather than holding a withdrawn response for the whole `ttl`.\n   *\n   * `must-revalidate` only where there is no stale window to protect: it\n   * forbids serving stale at all, which is the opposite of what `swr` asks\n   * for, so emitting both would leave the pair contradicting each other.\n   */\n  private browserCacheControl(resolved: ResolvedCacheable): string {\n    const parts = ['public', `max-age=${resolved.browserTtl}`]\n\n    if (resolved.swr !== undefined) parts.push(`stale-while-revalidate=${resolved.swr}`)\n    else if (resolved.browserTtl === 0) parts.push('must-revalidate')\n\n    return parts.join(', ')\n  }\n\n  /** The lifetime, for the cache that can be purged. */\n  private sharedCacheControl(resolved: ResolvedCacheable): string {\n    const parts = ['public', `max-age=${resolved.ttl}`]\n    if (resolved.swr !== undefined) parts.push(`stale-while-revalidate=${resolved.swr}`)\n    return parts.join(', ')\n  }\n\n  /** Union the declared Vary names with whatever the response already set. */\n  private mergeVary(response: Response, declared: string[]): string | null {\n    const existing = (response.headers.get('Vary') ?? '')\n      .split(',')\n      .map((v) => v.trim())\n      .filter(Boolean)\n\n    const merged = [...new Set([...existing, ...declared])]\n    return merged.length > 0 ? merged.join(', ') : null\n  }\n\n  /**\n   * Overlay headers onto the response, mutating in place when the header\n   * list is writable — see `setResponseHeaders` for why that's the common\n   * case and safe. `Cache-Tag` and `CDN-Cache-Control` are explicitly deleted\n   * (not just omitted) when degrading to `no-store`, so neither a stale tag\n   * nor a lifetime from a differently-decided response lingers. The second\n   * matters most: Cloudflare reads `CDN-Cache-Control` in preference to\n   * `Cache-Control`, so one left behind would cache a response this just\n   * refused to cache.\n   */\n  private withHeaders(response: Response, headers: Record<string, string>): Response {\n    const toSet: Record<string, string | null> = { ...headers }\n    if (headers['Cache-Control'] === NO_STORE) {\n      toSet['Cache-Tag'] = null\n      toSet['CDN-Cache-Control'] = null\n    }\n\n    return setResponseHeaders(response, toSet)\n  }\n}\n","import type { Constructor } from '../../types'\nimport { inject } from '../../di'\nimport { Singleton } from '../../di/decorators'\nimport { LOGGER_TOKENS, type LoggerService } from '../../logger'\nimport type { Middleware } from '../../router/middleware.interface'\nimport type { RouterContext } from '../../router/router-context'\nimport { RESPONSE_CACHE_TOKENS } from '../response-cache.tokens'\nimport type { ResponseCacheModuleOptions } from '../types'\n\n/**\n * Runs registered middleware in the gateway before partition resolution, so a\n * resolver sees the same `RouterContext` it would inside the app.\n *\n * `ctx.user()` is a macro over the request-scoped `AuthContext`, which\n * `SessionVerificationMiddleware` populates imperatively inside the app's\n * middleware chain. Without priming, that chain has not run and `ctx.user()`\n * throws. `AuthModule` does **not** register anything here: `@stratal/\n * framework` exports `AUTH_GATEWAY_PRIMERS`, which a consumer passes\n * explicitly via `ResponseCacheModule.forRoot({ primers })`.\n *\n * Called by `createGatewayDispatchMiddleware`, and only for `@Cacheable`\n * routes that declare `partitionBy` — a public cacheable route and every\n * non-cacheable route skip the chain entirely.\n */\n@Singleton(RESPONSE_CACHE_TOKENS.GatewayPrimerService)\nexport class GatewayPrimerService {\n  constructor(\n    @inject(RESPONSE_CACHE_TOKENS.Options) private readonly options: ResponseCacheModuleOptions,\n    @inject(LOGGER_TOKENS.LoggerService) private readonly logger: LoggerService,\n  ) {}\n\n  get hasPrimers(): boolean {\n    return (this.options.primers?.length ?? 0) > 0\n  }\n\n  /**\n   * Run every primer in registration order.\n   *\n   * @returns `true` when the whole chain ran to completion, `false` when a\n   *   primer short-circuited.\n   *\n   * `Middleware.handle` may return a `Response` to short-circuit its chain — an\n   * auth middleware rejecting a request, for example. In the gateway that\n   * `Response` is **not** the answer to send: primers run only to populate the\n   * request container before partition resolution, and the real middleware\n   * chain still runs inside the app, where the same middleware will produce the\n   * same rejection through the application's own pipeline (exception handler,\n   * logging, Inertia error shaping). Answering from the gateway would make it a\n   * second, partially-run response pipeline whose output is assembled by a\n   * *subset* of the app's middleware.\n   *\n   * So the `Response` is dropped — but not silently. A short-circuit means the\n   * container was never fully primed, so partition resolution cannot be\n   * trusted; the caller must fail closed and run the request inline instead of\n   * caching it.\n   */\n  async prime(ctx: RouterContext): Promise<boolean> {\n    const primers = this.options.primers ?? []\n    const container = ctx.getContainer()\n\n    for (const Primer of primers) {\n      const middleware = container.resolve<Middleware>(Primer as Constructor<Middleware>)\n      // Primers exist for their side effects on the request container, so the\n      // chain terminates here rather than continuing to a handler.\n      // eslint-disable-next-line @typescript-eslint/no-empty-function -- terminating next for side-effect middleware\n      const result = await middleware.handle(ctx, async () => {})\n\n      if (result instanceof Response) {\n        this.logger.debug('[stratal:response-cache] Primer short-circuited; not caching', {\n          primer: (Primer as Constructor<Middleware>).name,\n          status: result.status,\n        })\n        return false\n      }\n    }\n\n    return true\n  }\n}\n","import { Singleton } from '../../di/decorators'\nimport { RESPONSE_CACHE_TOKENS } from '../response-cache.tokens'\nimport type { CacheableOptions } from '../types'\n\n/**\n * What the dispatch middleware needs to know about one route.\n *\n * Typed as a `CacheableOptions` (every field optional) rather than a bespoke\n * shape so it can be handed straight to `shouldLoopback`, which already\n * encodes \"only GET/HEAD ever loop back\".\n */\nexport interface GatewayRouteEntry extends CacheableOptions {\n  partitionBy: string[]\n}\n\n/**\n * `${METHOD} ${routePath}` → the partitions that route declared.\n *\n * Populated once, at route registration, and only for routes whose\n * **effective** `partitionBy` (after module defaults) is non-empty. Every\n * other route is absent, and absence means \"run inline\" — the safe default,\n * and the one that keeps an app which uses no partitions paying nothing but a\n * single `isEmpty` check per request.\n *\n * The key is the route *pattern* Hono matched (`/posts/:id`), not the request\n * path, so one entry serves every request to that route.\n */\n@Singleton(RESPONSE_CACHE_TOKENS.GatewayRouteTable)\nexport class GatewayRouteTable {\n  private readonly entries = new Map<string, GatewayRouteEntry>()\n\n  /**\n   * The consumer's `export const <name> = cachedEntrypoint(stratal)`, from\n   * `ResponseCacheModule.forRoot({ gateway: { entrypoint } })`.\n   *\n   * `undefined` means no gateway is configured, which is also the condition\n   * under which `bindRouteCache` refuses a non-empty `partitionBy` — so an\n   * unconfigured table is always an empty one.\n   */\n  entrypoint: string | undefined\n\n  /**\n   * `gateway.keyBy` — the request headers whose values join the cache key.\n   *\n   * Carried here rather than resolved per request because the dispatch\n   * middleware already memoises this table, so reading it costs a property\n   * access on the hot path instead of a container lookup.\n   */\n  keyBy: readonly string[] = []\n\n  /** Set by `RouteRegistrationService.configure()`, before any request. */\n  configure(entrypoint: string | undefined, keyBy: readonly string[] = []): void {\n    this.entrypoint = entrypoint\n    this.keyBy = keyBy\n  }\n\n  /** True when no route in this app declares a partition. */\n  get isEmpty(): boolean {\n    return this.entries.size === 0\n  }\n\n  /** Number of recorded routes. Test/diagnostic affordance. */\n  get size(): number {\n    return this.entries.size\n  }\n\n  /**\n   * Record one registered route.\n   *\n   * `method` is the Hono-registered method; `path` is the pattern the route\n   * was registered under (already expanded for versioning and locale\n   * variants, so each variant gets its own entry).\n   */\n  record(method: string, path: string, partitionBy: string[]): void {\n    if (partitionBy.length === 0) return\n    this.entries.set(`${method.toUpperCase()} ${path}`, { partitionBy })\n  }\n\n  /** The entry for a matched route pattern, or `undefined` to run inline. */\n  lookup(method: string, path: string): GatewayRouteEntry | undefined {\n    return this.entries.get(`${method.toUpperCase()} ${path}`)\n  }\n}\n","import { inject } from '../../di'\nimport { Singleton } from '../../di/decorators'\nimport { LOGGER_TOKENS, type LoggerService } from '../../logger'\nimport type { RouterContext } from '../../router/router-context'\nimport { ResponseCacheConfigError } from '../errors'\nimport { RESPONSE_CACHE_TOKENS } from '../response-cache.tokens'\nimport type { ResponseCacheModuleOptions } from '../types'\n\nexport interface PartitionResult {\n  /** Values to place in `ctx.props`. Empty when nothing resolved. */\n  props: Record<string, string>\n  /** False when any declared partition could not be resolved — do not cache. */\n  resolved: boolean\n}\n\n/**\n * Resolves the named partitions a route declared into `ctx.props` values.\n *\n * `ctx.props` is part of the Workers Caching cache key and, per Cloudflare,\n * \"cannot be bypassed\" — so this is what keeps one caller's cached response\n * from reaching another.\n */\n@Singleton(RESPONSE_CACHE_TOKENS.PartitionResolverService)\nexport class PartitionResolverService {\n  constructor(\n    @inject(RESPONSE_CACHE_TOKENS.Options) private readonly options: ResponseCacheModuleOptions,\n    @inject(LOGGER_TOKENS.LoggerService) private readonly logger: LoggerService,\n  ) {}\n\n  /** Throw at boot if a route names a partition with no registered resolver. */\n  assertKnown(names: string[], where: string): void {\n    const known = Object.keys(this.options.partitions ?? {})\n\n    for (const name of names) {\n      if (!known.includes(name)) {\n        throw new ResponseCacheConfigError(\n          `${where}: unknown partition \"${name}\". Register it via ` +\n            `ResponseCacheModule.forRoot({ partitions: { ${name}: (ctx) => ... } }). ` +\n            `Known partitions: ${known.length > 0 ? known.join(', ') : '(none)'}.`,\n        )\n      }\n    }\n  }\n\n  /**\n   * Partition names seen so far, split by whether they have ever resolved.\n   *\n   * A resolver that fails is ordinary traffic — an anonymous visitor to a\n   * per-user route — so the per-request signal stays at `debug`. But a\n   * partition that has *never* resolved is a configuration mistake, not\n   * traffic: the usual cause is `partitions: { user: (ctx) => ctx.user().id }`\n   * configured without `primers: AUTH_GATEWAY_PRIMERS`, so `ctx.user()` throws\n   * on every request and the route is silently never cached. Warned once per\n   * name, so that diagnosis is available without making normal misses noisy.\n   */\n  private readonly warnedUnresolved = new Set<string>()\n  private readonly everResolved = new Set<string>()\n\n  private noteUnresolved(name: string): void {\n    if (this.everResolved.has(name) || this.warnedUnresolved.has(name)) return\n\n    this.warnedUnresolved.add(name)\n    this.logger.warn(\n      `[stratal:response-cache] Partition \"${name}\" has never resolved; routes using it are ` +\n        'not being cached. If its resolver calls `ctx.user()` or reads the request container, ' +\n        'the gateway needs `primers` (e.g. `AUTH_GATEWAY_PRIMERS` from @stratal/framework) to ' +\n        'populate that context before resolution runs.',\n      { partition: name },\n    )\n  }\n\n  async resolve(ctx: RouterContext, names: string[]): Promise<PartitionResult> {\n    if (names.length === 0) return { props: {}, resolved: true }\n\n    const partitions = this.options.partitions ?? {}\n    const props: Record<string, string> = {}\n\n    for (const name of names) {\n      const resolver = partitions[name]\n      if (!resolver) return { props: {}, resolved: false }\n\n      let value: string | null | undefined\n      try {\n        value = await resolver(ctx)\n      } catch (error) {\n        // An anonymous request to a per-user route makes ctx.user() throw.\n        // That is ordinary traffic, not a fault — it just is not cacheable.\n        this.logger.debug('[stratal:response-cache] Partition resolver threw; not caching', {\n          partition: name,\n          error,\n        })\n        this.noteUnresolved(name)\n        return { props: {}, resolved: false }\n      }\n\n      if (value === null || value === undefined) {\n        this.logger.debug('[stratal:response-cache] Partition unresolved; not caching', { partition: name })\n        this.noteUnresolved(name)\n        return { props: {}, resolved: false }\n      }\n\n      this.everResolved.add(name)\n      props[name] = value\n    }\n\n    return { props, resolved: true }\n  }\n}\n","import { inject } from '../../di'\nimport { Singleton } from '../../di/decorators'\nimport { LOGGER_TOKENS, type LoggerService } from '../../logger'\nimport { CachePurgeError } from '../errors'\nimport { RESPONSE_CACHE_TOKENS } from '../response-cache.tokens'\nimport { renderTags, type TagScopes } from '../tag-template'\nimport type { PurgesCacheOptions } from '../types'\n\n// Declared on `StratalExecutionContext` so the foundational module does not\n// have to depend on this feature to describe `ctx.cache`. Re-exported here (and\n// from `stratal/response-cache`) so consumers import them alongside the API\n// that uses them.\nimport type { PurgeSpec, WorkersCache } from '../../execution-context'\n\nexport type { PurgeSpec, WorkersCache }\n\n@Singleton(RESPONSE_CACHE_TOKENS.ResponseCacheService)\nexport class ResponseCacheService {\n  constructor(\n    @inject(LOGGER_TOKENS.LoggerService) private readonly logger: LoggerService,\n  ) {}\n\n  /** Render a `@PurgesCache` declaration against this request's scopes. */\n  buildPurgeSpec(options: PurgesCacheOptions, scopes: TagScopes): PurgeSpec {\n    if (options.purgeEverything) return { purgeEverything: true }\n\n    const spec: PurgeSpec = {}\n    if (options.tags?.length) spec.tags = renderTags(options.tags, scopes)\n    if (options.pathPrefixes?.length) spec.pathPrefixes = [...options.pathPrefixes]\n\n    return spec\n  }\n\n  /**\n   * Issue a purge and wait for it.\n   *\n   * Deliberately not deferred through `waitUntil`: a client that re-reads\n   * immediately after its own write must not be served the pre-write response.\n   *\n   * @throws {CachePurgeError} The mutation has already committed at this point,\n   *   so failing loudly is the lesser evil against a cache that is silently\n   *   inconsistent with the database.\n   */\n  async purge(spec: PurgeSpec, cache: WorkersCache): Promise<void> {\n    try {\n      const result = await cache.purge(spec)\n\n      if (result && ! result.success) {\n        this.logger.error('[stratal:response-cache] Purge reported failure', { spec })\n        throw new CachePurgeError(`the runtime reported failure for ${JSON.stringify(spec)}`)\n      }\n    } catch (error) {\n      if (error instanceof CachePurgeError) throw error\n\n      this.logger.error('[stratal:response-cache] Purge threw', {\n        spec,\n        error: error instanceof Error ? error.message : String(error),\n      })\n      throw new CachePurgeError(error instanceof Error ? error.message : String(error))\n    }\n  }\n}\n","import { Module } from '../module'\nimport type { AsyncModuleOptions, DynamicModule } from '../module/types'\nimport { assertNoGatewayOptions } from './boot-check'\nimport { CacheabilityService, GatewayPrimerService, GatewayRouteTable, PartitionResolverService, ResponseCacheService } from './services'\nimport { RESPONSE_CACHE_TOKENS } from './response-cache.tokens'\nimport type { ResponseCacheModuleOptions } from './types'\n\n/**\n * Response caching on Cloudflare Workers Caching — opt-in, NOT registered\n * automatically by `Application`.\n *\n * Requires `cache.enabled = true` in the Wrangler config, Wrangler >= 4.69.0,\n * and `compatibility_date >= 2026-07-06`. Without that binding, a route\n * decorated with `@PurgesCache` throws `CachePurgeError` **at request time**\n * — after its mutation has already committed — rather than silently\n * skipping the purge and leaving the cache stale. Fail-loud is deliberate\n * here, but it does mean a `@PurgesCache` route deployed to an environment\n * that forgot `cache.enabled` turns every successful mutation into a `500`;\n * confirm the binding is present in every environment that uses it.\n *\n * `forRootAsync`'s `useFactory` **must be synchronous**, or resolve\n * synchronously from the caller's perspective: route registration reads\n * `defaults` before any async work this module kicks off could settle, so\n * an async factory's `Promise` is read as the options object itself,\n * silently discarding `defaults` (this is detected and throws at boot,\n * rather than silently caching without the intended defaults).\n *\n * Per-caller caching needs the gateway: `partitionBy`, `partitions`, and\n * `primers` all throw `ResponseCacheConfigError` at boot unless\n * `gateway: { entrypoint }` names a cached entrypoint built with\n * `cachedEntrypoint(stratal)` from `stratal/workers`. A route that declares a\n * partition it cannot honour must fail loudly rather than cache per-user data\n * publicly.\n *\n * ```typescript\n * @Module({\n *   imports: [ResponseCacheModule.forRoot({\n *     defaults: { ttl: 300, swr: 60, vary: ['Accept-Language'] },\n *   })],\n * })\n * export class AppModule {}\n * ```\n *\n * With per-caller partitioning:\n *\n * ```typescript\n * // app.module.ts\n * ResponseCacheModule.forRoot({\n *   gateway: { entrypoint: 'Cached' },\n *   partitions: { user: (ctx) => ctx.user().id },\n * })\n *\n * // src/index.ts\n * const stratal = new Stratal({ module: AppModule })\n * export default stratal\n * export const Cached = cachedEntrypoint(stratal)\n * ```\n */\n@Module({\n  providers: [\n    { provide: RESPONSE_CACHE_TOKENS.CacheabilityService, useClass: CacheabilityService },\n    { provide: RESPONSE_CACHE_TOKENS.PartitionResolverService, useClass: PartitionResolverService },\n    { provide: RESPONSE_CACHE_TOKENS.GatewayPrimerService, useClass: GatewayPrimerService },\n    { provide: RESPONSE_CACHE_TOKENS.ResponseCacheService, useClass: ResponseCacheService },\n    { provide: RESPONSE_CACHE_TOKENS.GatewayRouteTable, useClass: GatewayRouteTable },\n  ],\n})\nexport class ResponseCacheModule {\n  static forRoot(options: ResponseCacheModuleOptions = {}): DynamicModule {\n    assertNoGatewayOptions(options)\n\n    return {\n      module: ResponseCacheModule,\n      providers: [{ provide: RESPONSE_CACHE_TOKENS.Options, useValue: options }],\n    }\n  }\n\n  static forRootAsync(options: AsyncModuleOptions<ResponseCacheModuleOptions>): DynamicModule {\n    return {\n      module: ResponseCacheModule,\n      providers: [\n        {\n          provide: RESPONSE_CACHE_TOKENS.Options,\n          // Same rejection as `forRoot`, applied to whatever the factory\n          // produced. A `Promise` is passed through untouched: an async\n          // factory is its own boot error, raised in\n          // `RouteRegistrationService.responseCacheDefaults()` with a message\n          // about the real problem — inspecting a Promise for `partitions`\n          // here would only report a missing option instead.\n          useFactory: (...deps: unknown[]) => {\n            const resolved = options.useFactory(...deps)\n            if (!(resolved instanceof Promise)) assertNoGatewayOptions(resolved)\n            return resolved\n          },\n          inject: options.inject ?? [],\n        },\n      ],\n    }\n  }\n}\n"],"mappings":"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"}

package/dist/response-cache.error-B4D0zy9W.mjs

@@ -0,0 +1,24 @@
+import { a as ApplicationError } from "./container-storage-DfF7SXdV.mjs";
+//#region src/response-cache/errors/response-cache.error.ts
+/** A rendered `Cache-Tag` value Cloudflare would silently drop. */
+var InvalidCacheTagError = class extends ApplicationError {
+	constructor(tag, reason) {
+		super(`[stratal:response-cache] Invalid Cache-Tag "${tag}": ${reason}`);
+	}
+};
+/** A purge failed after its mutation already committed. */
+var CachePurgeError = class extends ApplicationError {
+	constructor(detail, cause) {
+		super(`[stratal:response-cache] Cache purge failed: ${detail}`, cause);
+	}
+};
+/** Misconfiguration detected at boot. */
+var ResponseCacheConfigError = class extends ApplicationError {
+	constructor(detail) {
+		super(`[stratal:response-cache] ${detail}`);
+	}
+};
+//#endregion
+export { InvalidCacheTagError as n, ResponseCacheConfigError as r, CachePurgeError as t };
+
+//# sourceMappingURL=response-cache.error-B4D0zy9W.mjs.map

package/dist/response-cache.error-B4D0zy9W.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"response-cache.error-B4D0zy9W.mjs","names":[],"sources":["../src/response-cache/errors/response-cache.error.ts"],"sourcesContent":["import { ApplicationError } from '../../errors'\n\n/** A rendered `Cache-Tag` value Cloudflare would silently drop. */\nexport class InvalidCacheTagError extends ApplicationError {\n  constructor(tag: string, reason: string) {\n    super(`[stratal:response-cache] Invalid Cache-Tag \"${tag}\": ${reason}`)\n  }\n}\n\n/** A purge failed after its mutation already committed. */\nexport class CachePurgeError extends ApplicationError {\n  constructor(detail: string, cause?: unknown) {\n    super(`[stratal:response-cache] Cache purge failed: ${detail}`, cause)\n  }\n}\n\n/** Misconfiguration detected at boot. */\nexport class ResponseCacheConfigError extends ApplicationError {\n  constructor(detail: string) {\n    super(`[stratal:response-cache] ${detail}`)\n  }\n}\n"],"mappings":";;;AAGA,IAAa,uBAAb,cAA0C,iBAAiB;CACzD,YAAY,KAAa,QAAgB;EACvC,MAAM,+CAA+C,IAAI,KAAK,QAAQ;CACxE;AACF;;AAGA,IAAa,kBAAb,cAAqC,iBAAiB;CACpD,YAAY,QAAgB,OAAiB;EAC3C,MAAM,gDAAgD,UAAU,KAAK;CACvE;AACF;;AAGA,IAAa,2BAAb,cAA8C,iBAAiB;CAC7D,YAAY,QAAgB;EAC1B,MAAM,4BAA4B,QAAQ;CAC5C;AACF"}