@timber-js/app 0.2.0-alpha.21 → 0.2.0-alpha.210

package/dist/cdn/cloudflare-purge.js

@@ -0,0 +1,30 @@
+//#region src/cdn/cloudflare-purge.ts
+var CloudflarePurge = class {
+	zoneId;
+	apiToken;
+	_fetch;
+	constructor(opts) {
+		this.zoneId = opts.zoneId;
+		this.apiToken = opts.apiToken;
+		this._fetch = opts.fetch ?? globalThis.fetch;
+	}
+	async purgeTags(tags) {
+		if (tags.length === 0) return;
+		const res = await this._fetch(`https://api.cloudflare.com/client/v4/zones/${this.zoneId}/purge_cache`, {
+			method: "POST",
+			headers: {
+				"Authorization": `Bearer ${this.apiToken}`,
+				"Content-Type": "application/json"
+			},
+			body: JSON.stringify({ tags })
+		});
+		if (!res.ok) {
+			const body = await res.text();
+			throw new Error(`Cloudflare purge failed (${res.status}): ${body}`);
+		}
+	}
+};
+//#endregion
+export { CloudflarePurge };
+
+//# sourceMappingURL=cloudflare-purge.js.map

package/dist/cdn/cloudflare-purge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloudflare-purge.js","names":[],"sources":["../../src/cdn/cloudflare-purge.ts"],"sourcesContent":["/**\n * Cloudflare CDN purge handler — purges by cache tag via the Cloudflare API.\n *\n * Requires Cloudflare Enterprise for tag-based purging.\n * See https://developers.cloudflare.com/cache/how-to/purge-cache/purge-by-tags/\n */\n\nimport type { CdnPurgeHandler } from './purge-store.ts';\n\nexport interface CloudflarePurgeOptions {\n  /** Cloudflare zone ID. */\n  zoneId: string;\n  /** API token with Cache Purge permission. */\n  apiToken: string;\n  /** Override fetch for testing. */\n  fetch?: typeof globalThis.fetch;\n}\n\nexport class CloudflarePurge implements CdnPurgeHandler {\n  private readonly zoneId: string;\n  private readonly apiToken: string;\n  private readonly _fetch: typeof globalThis.fetch;\n\n  constructor(opts: CloudflarePurgeOptions) {\n    this.zoneId = opts.zoneId;\n    this.apiToken = opts.apiToken;\n    this._fetch = opts.fetch ?? globalThis.fetch;\n  }\n\n  async purgeTags(tags: string[]): Promise<void> {\n    if (tags.length === 0) return;\n\n    const res = await this._fetch(\n      `https://api.cloudflare.com/client/v4/zones/${this.zoneId}/purge_cache`,\n      {\n        method: 'POST',\n        headers: {\n          'Authorization': `Bearer ${this.apiToken}`,\n          'Content-Type': 'application/json',\n        },\n        body: JSON.stringify({ tags }),\n      }\n    );\n\n    if (!res.ok) {\n      const body = await res.text();\n      throw new Error(`Cloudflare purge failed (${res.status}): ${body}`);\n    }\n  }\n}\n"],"mappings":";AAkBA,IAAa,kBAAb,MAAwD;CACtD;CACA;CACA;CAEA,YAAY,MAA8B;EACxC,KAAK,SAAS,KAAK;EACnB,KAAK,WAAW,KAAK;EACrB,KAAK,SAAS,KAAK,SAAS,WAAW;CACzC;CAEA,MAAM,UAAU,MAA+B;EAC7C,IAAI,KAAK,WAAW,GAAG;EAEvB,MAAM,MAAM,MAAM,KAAK,OACrB,8CAA8C,KAAK,OAAO,eAC1D;GACE,QAAQ;GACR,SAAS;IACP,iBAAiB,UAAU,KAAK;IAChC,gBAAgB;GAClB;GACA,MAAM,KAAK,UAAU,EAAE,KAAK,CAAC;EAC/B,CACF;EAEA,IAAI,CAAC,IAAI,IAAI;GACX,MAAM,OAAO,MAAM,IAAI,KAAK;GAC5B,MAAM,IAAI,MAAM,4BAA4B,IAAI,OAAO,KAAK,MAAM;EACpE;CACF;AACF"}

package/dist/cdn/fastly-purge.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Fastly CDN purge handler — purges by surrogate key via the Fastly API.
+ *
+ * See https://www.fastly.com/documentation/reference/api/purging/
+ */
+import type { CdnPurgeHandler } from './purge-store.ts';
+export interface FastlyPurgeOptions {
+    /** Fastly service ID. */
+    serviceId: string;
+    /** Fastly API token with purge permission. */
+    apiToken: string;
+    /** Use soft purge (marks as stale instead of immediate delete). Default: false. */
+    softPurge?: boolean;
+    /** Override fetch for testing. */
+    fetch?: typeof globalThis.fetch;
+}
+export declare class FastlyPurge implements CdnPurgeHandler {
+    private readonly serviceId;
+    private readonly apiToken;
+    private readonly softPurge;
+    private readonly _fetch;
+    constructor(opts: FastlyPurgeOptions);
+    purgeTags(tags: string[]): Promise<void>;
+}
+//# sourceMappingURL=fastly-purge.d.ts.map

package/dist/cdn/fastly-purge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fastly-purge.d.ts","sourceRoot":"","sources":["../../src/cdn/fastly-purge.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAExD,MAAM,WAAW,kBAAkB;IACjC,yBAAyB;IACzB,SAAS,EAAE,MAAM,CAAC;IAClB,8CAA8C;IAC9C,QAAQ,EAAE,MAAM,CAAC;IACjB,mFAAmF;IACnF,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,kCAAkC;IAClC,KAAK,CAAC,EAAE,OAAO,UAAU,CAAC,KAAK,CAAC;CACjC;AAED,qBAAa,WAAY,YAAW,eAAe;IACjD,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAS;IACnC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAU;IACpC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA0B;IAEjD,YAAY,IAAI,EAAE,kBAAkB,EAKnC;IAEK,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CA6B7C;CACF"}

package/dist/cdn/fastly-purge.js

@@ -0,0 +1,33 @@
+//#region src/cdn/fastly-purge.ts
+var FastlyPurge = class {
+	serviceId;
+	apiToken;
+	softPurge;
+	_fetch;
+	constructor(opts) {
+		this.serviceId = opts.serviceId;
+		this.apiToken = opts.apiToken;
+		this.softPurge = opts.softPurge ?? false;
+		this._fetch = opts.fetch ?? globalThis.fetch;
+	}
+	async purgeTags(tags) {
+		if (tags.length === 0) return;
+		const failures = (await Promise.allSettled(tags.map((tag) => this._fetch(`https://api.fastly.com/service/${this.serviceId}/purge/${encodeURIComponent(tag)}`, {
+			method: "POST",
+			headers: {
+				"Fastly-Key": this.apiToken,
+				...this.softPurge ? { "Fastly-Soft-Purge": "1" } : {}
+			}
+		}).then(async (res) => {
+			if (!res.ok) {
+				const body = await res.text();
+				throw new Error(`Fastly purge failed for tag "${tag}" (${res.status}): ${body}`);
+			}
+		})))).filter((r) => r.status === "rejected");
+		if (failures.length > 0) throw new Error(`Fastly purge failed for ${failures.length}/${tags.length} tags: ${failures.map((f) => f.reason?.message).join("; ")}`);
+	}
+};
+//#endregion
+export { FastlyPurge };
+
+//# sourceMappingURL=fastly-purge.js.map

package/dist/cdn/fastly-purge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fastly-purge.js","names":[],"sources":["../../src/cdn/fastly-purge.ts"],"sourcesContent":["/**\n * Fastly CDN purge handler — purges by surrogate key via the Fastly API.\n *\n * See https://www.fastly.com/documentation/reference/api/purging/\n */\n\nimport type { CdnPurgeHandler } from './purge-store.ts';\n\nexport interface FastlyPurgeOptions {\n  /** Fastly service ID. */\n  serviceId: string;\n  /** Fastly API token with purge permission. */\n  apiToken: string;\n  /** Use soft purge (marks as stale instead of immediate delete). Default: false. */\n  softPurge?: boolean;\n  /** Override fetch for testing. */\n  fetch?: typeof globalThis.fetch;\n}\n\nexport class FastlyPurge implements CdnPurgeHandler {\n  private readonly serviceId: string;\n  private readonly apiToken: string;\n  private readonly softPurge: boolean;\n  private readonly _fetch: typeof globalThis.fetch;\n\n  constructor(opts: FastlyPurgeOptions) {\n    this.serviceId = opts.serviceId;\n    this.apiToken = opts.apiToken;\n    this.softPurge = opts.softPurge ?? false;\n    this._fetch = opts.fetch ?? globalThis.fetch;\n  }\n\n  async purgeTags(tags: string[]): Promise<void> {\n    if (tags.length === 0) return;\n\n    const results = await Promise.allSettled(\n      tags.map((tag) =>\n        this._fetch(\n          `https://api.fastly.com/service/${this.serviceId}/purge/${encodeURIComponent(tag)}`,\n          {\n            method: 'POST',\n            headers: {\n              'Fastly-Key': this.apiToken,\n              ...(this.softPurge ? { 'Fastly-Soft-Purge': '1' } : {}),\n            },\n          }\n        ).then(async (res) => {\n          if (!res.ok) {\n            const body = await res.text();\n            throw new Error(`Fastly purge failed for tag \"${tag}\" (${res.status}): ${body}`);\n          }\n        })\n      )\n    );\n\n    const failures = results.filter((r): r is PromiseRejectedResult => r.status === 'rejected');\n    if (failures.length > 0) {\n      throw new Error(\n        `Fastly purge failed for ${failures.length}/${tags.length} tags: ${failures.map((f) => f.reason?.message).join('; ')}`\n      );\n    }\n  }\n}\n"],"mappings":";AAmBA,IAAa,cAAb,MAAoD;CAClD;CACA;CACA;CACA;CAEA,YAAY,MAA0B;EACpC,KAAK,YAAY,KAAK;EACtB,KAAK,WAAW,KAAK;EACrB,KAAK,YAAY,KAAK,aAAa;EACnC,KAAK,SAAS,KAAK,SAAS,WAAW;CACzC;CAEA,MAAM,UAAU,MAA+B;EAC7C,IAAI,KAAK,WAAW,GAAG;EAsBvB,MAAM,YAAW,MApBK,QAAQ,WAC5B,KAAK,KAAK,QACR,KAAK,OACH,kCAAkC,KAAK,UAAU,SAAS,mBAAmB,GAAG,KAChF;GACE,QAAQ;GACR,SAAS;IACP,cAAc,KAAK;IACnB,GAAI,KAAK,YAAY,EAAE,qBAAqB,IAAI,IAAI,CAAC;GACvD;EACF,CACF,CAAC,CAAC,KAAK,OAAO,QAAQ;GACpB,IAAI,CAAC,IAAI,IAAI;IACX,MAAM,OAAO,MAAM,IAAI,KAAK;IAC5B,MAAM,IAAI,MAAM,gCAAgC,IAAI,KAAK,IAAI,OAAO,KAAK,MAAM;GACjF;EACF,CAAC,CACH,CACF,EAAA,CAEyB,QAAQ,MAAkC,EAAE,WAAW,UAAU;EAC1F,IAAI,SAAS,SAAS,GACpB,MAAM,IAAI,MACR,2BAA2B,SAAS,OAAO,GAAG,KAAK,OAAO,SAAS,SAAS,KAAK,MAAM,EAAE,QAAQ,OAAO,CAAC,CAAC,KAAK,IAAI,GACrH;CAEJ;AACF"}

package/dist/cdn/headers.d.ts

@@ -0,0 +1,97 @@
+/**
+ * CDN header helpers — pure functions that build Cache-Control,
+ * CDN-Cache-Control, Surrogate-Control, and Surrogate-Key header values.
+ *
+ * These are developer-elected utilities for wiring CDN caching in
+ * proxy.ts / middleware.ts. The framework never sets these automatically.
+ * See design/25-production-deployments.md §Layer 2.
+ */
+export interface CacheControlOptions {
+    /** Mark the response as publicly cacheable (CDN, shared caches). */
+    public?: boolean;
+    /** Mark the response as private (browser cache only, not CDN). */
+    private?: boolean;
+    /** Max freshness in seconds for the browser/client. */
+    maxAge?: number;
+    /** Max freshness in seconds for shared caches (CDN, proxy). Overrides maxAge for CDNs. */
+    sMaxAge?: number;
+    /** Serve stale while revalidating in the background (seconds). */
+    staleWhileRevalidate?: number;
+    /** Serve stale on upstream error (seconds). */
+    staleIfError?: number;
+    /** Response must not be stored by any cache. */
+    noStore?: boolean;
+    /** Caches must revalidate before using a stored response. */
+    noCache?: boolean;
+    /** Caches must revalidate once stale — no serving stale without checking origin. */
+    mustRevalidate?: boolean;
+    /** Response will not change — allows aggressive caching. Pair with hashed URLs. */
+    immutable?: boolean;
+}
+/**
+ * Build a `Cache-Control` header value.
+ *
+ * ```ts
+ * ctx.headers.set('Cache-Control', cacheControl({
+ *   public: true,
+ *   maxAge: 300,
+ *   staleWhileRevalidate: 60,
+ * }));
+ * ```
+ */
+export declare function cacheControl(opts: CacheControlOptions): string;
+export interface SurrogateControlOptions {
+    /** Max freshness in seconds for the surrogate (CDN). */
+    maxAge?: number;
+    /** Do not store in surrogate cache. */
+    noStore?: boolean;
+    /** Serve stale while revalidating (seconds). */
+    staleWhileRevalidate?: number;
+    /** Serve stale on error (seconds). */
+    staleIfError?: number;
+}
+/**
+ * Build a `Surrogate-Control` header value (Fastly, Akamai, Varnish).
+ *
+ * ```ts
+ * ctx.headers.set('Surrogate-Control', surrogateControl({ maxAge: 3600 }));
+ * ```
+ */
+export declare function surrogateControl(opts: SurrogateControlOptions): string;
+/**
+ * Build a `CDN-Cache-Control` header value (Cloudflare).
+ * Same directive syntax as Surrogate-Control but recognized by Cloudflare.
+ *
+ * ```ts
+ * ctx.headers.set('CDN-Cache-Control', cdnCacheControl({ maxAge: 3600 }));
+ * ```
+ */
+export declare function cdnCacheControl(opts: SurrogateControlOptions): string;
+/**
+ * Build a `Surrogate-Key` header value — space-separated tags for CDN
+ * tag-based purging (Fastly, Cloudflare Enterprise, Akamai).
+ *
+ * Tags are deduplicated. Tags must not contain spaces or double quotes
+ * (these are separators/delimiters in the header format).
+ *
+ * ```ts
+ * ctx.headers.set('Surrogate-Key', surrogateKey(['products', `product:${id}`]));
+ * ```
+ */
+export declare function surrogateKey(tags: string[]): string;
+/**
+ * Build a `Cache-Tag` header value — comma-separated tags for Cloudflare
+ * Workers Cache tag-based purging. Available on ALL Cloudflare plans.
+ *
+ * Tags are deduplicated. Tags must not contain commas (the delimiter).
+ * Maximum tag length is 1024 characters per Cloudflare's limits.
+ *
+ * Use this instead of `surrogateKey()` when using Cloudflare Workers Cache
+ * (ctx.cache.purge). Workers Cache reads `Cache-Tag`, not `Surrogate-Key`.
+ *
+ * ```ts
+ * ctx.headers.set('Cache-Tag', cacheTag(['products', `product:${id}`]));
+ * ```
+ */
+export declare function cacheTag(tags: string[]): string;
+//# sourceMappingURL=headers.d.ts.map

package/dist/cdn/headers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"headers.d.ts","sourceRoot":"","sources":["../../src/cdn/headers.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,MAAM,WAAW,mBAAmB;IAClC,oEAAoE;IACpE,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,kEAAkE;IAClE,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,uDAAuD;IACvD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,0FAA0F;IAC1F,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,kEAAkE;IAClE,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,+CAA+C;IAC/C,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,gDAAgD;IAChD,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,6DAA6D;IAC7D,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,oFAAoF;IACpF,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,mFAAmF;IACnF,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,mBAAmB,GAAG,MAAM,CAuB9D;AAED,MAAM,WAAW,uBAAuB;IACtC,wDAAwD;IACxD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,uCAAuC;IACvC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,gDAAgD;IAChD,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAC9B,sCAAsC;IACtC,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,uBAAuB,GAAG,MAAM,CAQtE;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,uBAAuB,GAAG,MAAM,CAErE;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM,CAOnD;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM,CAU/C"}

package/dist/cdn/index.d.ts

@@ -0,0 +1,5 @@
+export { cacheControl, surrogateKey, surrogateControl, cdnCacheControl, cacheTag, } from './headers.ts';
+export type { CacheControlOptions, SurrogateControlOptions } from './headers.ts';
+export { setCdnPurgeHandler, getCdnPurgeHandler } from './purge-store.ts';
+export type { CdnPurgeHandler } from './purge-store.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/cdn/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cdn/index.ts"],"names":[],"mappings":"AAKA,OAAO,EACL,YAAY,EACZ,YAAY,EACZ,gBAAgB,EAChB,eAAe,EACf,QAAQ,GACT,MAAM,cAAc,CAAC;AACtB,YAAY,EAAE,mBAAmB,EAAE,uBAAuB,EAAE,MAAM,cAAc,CAAC;AAEjF,OAAO,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,kBAAkB,CAAC;AAC1E,YAAY,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC"}

package/dist/cdn/index.js

@@ -0,0 +1,94 @@
+import { n as setCdnPurgeHandler, t as getCdnPurgeHandler } from "../_chunks/purge-store-Byr8XOjU.js";
+//#region src/cdn/headers.ts
+/**
+* Build a `Cache-Control` header value.
+*
+* ```ts
+* ctx.headers.set('Cache-Control', cacheControl({
+*   public: true,
+*   maxAge: 300,
+*   staleWhileRevalidate: 60,
+* }));
+* ```
+*/
+function cacheControl(opts) {
+	if (opts.public && opts.private) throw new Error("cacheControl: public and private are mutually exclusive");
+	if (opts.noStore && opts.maxAge !== void 0) throw new Error("cacheControl: noStore makes maxAge meaningless — remove one");
+	const parts = [];
+	parts.push(opts.public ? "public" : "private");
+	if (opts.noStore) parts.push("no-store");
+	if (opts.noCache) parts.push("no-cache");
+	if (opts.maxAge !== void 0) parts.push(`max-age=${opts.maxAge}`);
+	if (opts.sMaxAge !== void 0) parts.push(`s-maxage=${opts.sMaxAge}`);
+	if (opts.staleWhileRevalidate !== void 0) parts.push(`stale-while-revalidate=${opts.staleWhileRevalidate}`);
+	if (opts.staleIfError !== void 0) parts.push(`stale-if-error=${opts.staleIfError}`);
+	if (opts.mustRevalidate) parts.push("must-revalidate");
+	if (opts.immutable) parts.push("immutable");
+	return parts.join(", ");
+}
+/**
+* Build a `Surrogate-Control` header value (Fastly, Akamai, Varnish).
+*
+* ```ts
+* ctx.headers.set('Surrogate-Control', surrogateControl({ maxAge: 3600 }));
+* ```
+*/
+function surrogateControl(opts) {
+	const parts = [];
+	if (opts.noStore) parts.push("no-store");
+	if (opts.maxAge !== void 0) parts.push(`max-age=${opts.maxAge}`);
+	if (opts.staleWhileRevalidate !== void 0) parts.push(`stale-while-revalidate=${opts.staleWhileRevalidate}`);
+	if (opts.staleIfError !== void 0) parts.push(`stale-if-error=${opts.staleIfError}`);
+	return parts.join(", ");
+}
+/**
+* Build a `CDN-Cache-Control` header value (Cloudflare).
+* Same directive syntax as Surrogate-Control but recognized by Cloudflare.
+*
+* ```ts
+* ctx.headers.set('CDN-Cache-Control', cdnCacheControl({ maxAge: 3600 }));
+* ```
+*/
+function cdnCacheControl(opts) {
+	return surrogateControl(opts);
+}
+/**
+* Build a `Surrogate-Key` header value — space-separated tags for CDN
+* tag-based purging (Fastly, Cloudflare Enterprise, Akamai).
+*
+* Tags are deduplicated. Tags must not contain spaces or double quotes
+* (these are separators/delimiters in the header format).
+*
+* ```ts
+* ctx.headers.set('Surrogate-Key', surrogateKey(['products', `product:${id}`]));
+* ```
+*/
+function surrogateKey(tags) {
+	for (const tag of tags) if (tag.includes(" ") || tag.includes("\"")) throw new Error(`surrogateKey: tag "${tag}" must not contain spaces or double quotes`);
+	return [...new Set(tags)].join(" ");
+}
+/**
+* Build a `Cache-Tag` header value — comma-separated tags for Cloudflare
+* Workers Cache tag-based purging. Available on ALL Cloudflare plans.
+*
+* Tags are deduplicated. Tags must not contain commas (the delimiter).
+* Maximum tag length is 1024 characters per Cloudflare's limits.
+*
+* Use this instead of `surrogateKey()` when using Cloudflare Workers Cache
+* (ctx.cache.purge). Workers Cache reads `Cache-Tag`, not `Surrogate-Key`.
+*
+* ```ts
+* ctx.headers.set('Cache-Tag', cacheTag(['products', `product:${id}`]));
+* ```
+*/
+function cacheTag(tags) {
+	for (const tag of tags) {
+		if (tag.includes(",")) throw new Error(`cacheTag: tag "${tag}" must not contain commas`);
+		if (tag.length > 1024) throw new Error(`cacheTag: tag "${tag}" exceeds 1024-character limit`);
+	}
+	return [...new Set(tags)].join(",");
+}
+//#endregion
+export { cacheControl, cacheTag, cdnCacheControl, getCdnPurgeHandler, setCdnPurgeHandler, surrogateControl, surrogateKey };
+
+//# sourceMappingURL=index.js.map

package/dist/cdn/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../src/cdn/headers.ts"],"sourcesContent":["/**\n * CDN header helpers — pure functions that build Cache-Control,\n * CDN-Cache-Control, Surrogate-Control, and Surrogate-Key header values.\n *\n * These are developer-elected utilities for wiring CDN caching in\n * proxy.ts / middleware.ts. The framework never sets these automatically.\n * See design/25-production-deployments.md §Layer 2.\n */\n\nexport interface CacheControlOptions {\n  /** Mark the response as publicly cacheable (CDN, shared caches). */\n  public?: boolean;\n  /** Mark the response as private (browser cache only, not CDN). */\n  private?: boolean;\n  /** Max freshness in seconds for the browser/client. */\n  maxAge?: number;\n  /** Max freshness in seconds for shared caches (CDN, proxy). Overrides maxAge for CDNs. */\n  sMaxAge?: number;\n  /** Serve stale while revalidating in the background (seconds). */\n  staleWhileRevalidate?: number;\n  /** Serve stale on upstream error (seconds). */\n  staleIfError?: number;\n  /** Response must not be stored by any cache. */\n  noStore?: boolean;\n  /** Caches must revalidate before using a stored response. */\n  noCache?: boolean;\n  /** Caches must revalidate once stale — no serving stale without checking origin. */\n  mustRevalidate?: boolean;\n  /** Response will not change — allows aggressive caching. Pair with hashed URLs. */\n  immutable?: boolean;\n}\n\n/**\n * Build a `Cache-Control` header value.\n *\n * ```ts\n * ctx.headers.set('Cache-Control', cacheControl({\n *   public: true,\n *   maxAge: 300,\n *   staleWhileRevalidate: 60,\n * }));\n * ```\n */\nexport function cacheControl(opts: CacheControlOptions): string {\n  if (opts.public && opts.private) {\n    throw new Error('cacheControl: public and private are mutually exclusive');\n  }\n  if (opts.noStore && opts.maxAge !== undefined) {\n    throw new Error('cacheControl: noStore makes maxAge meaningless — remove one');\n  }\n\n  const parts: string[] = [];\n\n  parts.push(opts.public ? 'public' : 'private');\n\n  if (opts.noStore) parts.push('no-store');\n  if (opts.noCache) parts.push('no-cache');\n  if (opts.maxAge !== undefined) parts.push(`max-age=${opts.maxAge}`);\n  if (opts.sMaxAge !== undefined) parts.push(`s-maxage=${opts.sMaxAge}`);\n  if (opts.staleWhileRevalidate !== undefined)\n    parts.push(`stale-while-revalidate=${opts.staleWhileRevalidate}`);\n  if (opts.staleIfError !== undefined) parts.push(`stale-if-error=${opts.staleIfError}`);\n  if (opts.mustRevalidate) parts.push('must-revalidate');\n  if (opts.immutable) parts.push('immutable');\n\n  return parts.join(', ');\n}\n\nexport interface SurrogateControlOptions {\n  /** Max freshness in seconds for the surrogate (CDN). */\n  maxAge?: number;\n  /** Do not store in surrogate cache. */\n  noStore?: boolean;\n  /** Serve stale while revalidating (seconds). */\n  staleWhileRevalidate?: number;\n  /** Serve stale on error (seconds). */\n  staleIfError?: number;\n}\n\n/**\n * Build a `Surrogate-Control` header value (Fastly, Akamai, Varnish).\n *\n * ```ts\n * ctx.headers.set('Surrogate-Control', surrogateControl({ maxAge: 3600 }));\n * ```\n */\nexport function surrogateControl(opts: SurrogateControlOptions): string {\n  const parts: string[] = [];\n  if (opts.noStore) parts.push('no-store');\n  if (opts.maxAge !== undefined) parts.push(`max-age=${opts.maxAge}`);\n  if (opts.staleWhileRevalidate !== undefined)\n    parts.push(`stale-while-revalidate=${opts.staleWhileRevalidate}`);\n  if (opts.staleIfError !== undefined) parts.push(`stale-if-error=${opts.staleIfError}`);\n  return parts.join(', ');\n}\n\n/**\n * Build a `CDN-Cache-Control` header value (Cloudflare).\n * Same directive syntax as Surrogate-Control but recognized by Cloudflare.\n *\n * ```ts\n * ctx.headers.set('CDN-Cache-Control', cdnCacheControl({ maxAge: 3600 }));\n * ```\n */\nexport function cdnCacheControl(opts: SurrogateControlOptions): string {\n  return surrogateControl(opts);\n}\n\n/**\n * Build a `Surrogate-Key` header value — space-separated tags for CDN\n * tag-based purging (Fastly, Cloudflare Enterprise, Akamai).\n *\n * Tags are deduplicated. Tags must not contain spaces or double quotes\n * (these are separators/delimiters in the header format).\n *\n * ```ts\n * ctx.headers.set('Surrogate-Key', surrogateKey(['products', `product:${id}`]));\n * ```\n */\nexport function surrogateKey(tags: string[]): string {\n  for (const tag of tags) {\n    if (tag.includes(' ') || tag.includes('\"')) {\n      throw new Error(`surrogateKey: tag \"${tag}\" must not contain spaces or double quotes`);\n    }\n  }\n  return [...new Set(tags)].join(' ');\n}\n\n/**\n * Build a `Cache-Tag` header value — comma-separated tags for Cloudflare\n * Workers Cache tag-based purging. Available on ALL Cloudflare plans.\n *\n * Tags are deduplicated. Tags must not contain commas (the delimiter).\n * Maximum tag length is 1024 characters per Cloudflare's limits.\n *\n * Use this instead of `surrogateKey()` when using Cloudflare Workers Cache\n * (ctx.cache.purge). Workers Cache reads `Cache-Tag`, not `Surrogate-Key`.\n *\n * ```ts\n * ctx.headers.set('Cache-Tag', cacheTag(['products', `product:${id}`]));\n * ```\n */\nexport function cacheTag(tags: string[]): string {\n  for (const tag of tags) {\n    if (tag.includes(',')) {\n      throw new Error(`cacheTag: tag \"${tag}\" must not contain commas`);\n    }\n    if (tag.length > 1024) {\n      throw new Error(`cacheTag: tag \"${tag}\" exceeds 1024-character limit`);\n    }\n  }\n  return [...new Set(tags)].join(',');\n}\n"],"mappings":";;;;;;;;;;;;;AA2CA,SAAgB,aAAa,MAAmC;CAC9D,IAAI,KAAK,UAAU,KAAK,SACtB,MAAM,IAAI,MAAM,yDAAyD;CAE3E,IAAI,KAAK,WAAW,KAAK,WAAW,KAAA,GAClC,MAAM,IAAI,MAAM,6DAA6D;CAG/E,MAAM,QAAkB,CAAC;CAEzB,MAAM,KAAK,KAAK,SAAS,WAAW,SAAS;CAE7C,IAAI,KAAK,SAAS,MAAM,KAAK,UAAU;CACvC,IAAI,KAAK,SAAS,MAAM,KAAK,UAAU;CACvC,IAAI,KAAK,WAAW,KAAA,GAAW,MAAM,KAAK,WAAW,KAAK,QAAQ;CAClE,IAAI,KAAK,YAAY,KAAA,GAAW,MAAM,KAAK,YAAY,KAAK,SAAS;CACrE,IAAI,KAAK,yBAAyB,KAAA,GAChC,MAAM,KAAK,0BAA0B,KAAK,sBAAsB;CAClE,IAAI,KAAK,iBAAiB,KAAA,GAAW,MAAM,KAAK,kBAAkB,KAAK,cAAc;CACrF,IAAI,KAAK,gBAAgB,MAAM,KAAK,iBAAiB;CACrD,IAAI,KAAK,WAAW,MAAM,KAAK,WAAW;CAE1C,OAAO,MAAM,KAAK,IAAI;AACxB;;;;;;;;AAoBA,SAAgB,iBAAiB,MAAuC;CACtE,MAAM,QAAkB,CAAC;CACzB,IAAI,KAAK,SAAS,MAAM,KAAK,UAAU;CACvC,IAAI,KAAK,WAAW,KAAA,GAAW,MAAM,KAAK,WAAW,KAAK,QAAQ;CAClE,IAAI,KAAK,yBAAyB,KAAA,GAChC,MAAM,KAAK,0BAA0B,KAAK,sBAAsB;CAClE,IAAI,KAAK,iBAAiB,KAAA,GAAW,MAAM,KAAK,kBAAkB,KAAK,cAAc;CACrF,OAAO,MAAM,KAAK,IAAI;AACxB;;;;;;;;;AAUA,SAAgB,gBAAgB,MAAuC;CACrE,OAAO,iBAAiB,IAAI;AAC9B;;;;;;;;;;;;AAaA,SAAgB,aAAa,MAAwB;CACnD,KAAK,MAAM,OAAO,MAChB,IAAI,IAAI,SAAS,GAAG,KAAK,IAAI,SAAS,IAAG,GACvC,MAAM,IAAI,MAAM,sBAAsB,IAAI,2CAA2C;CAGzF,OAAO,CAAC,GAAG,IAAI,IAAI,IAAI,CAAC,CAAC,CAAC,KAAK,GAAG;AACpC;;;;;;;;;;;;;;;AAgBA,SAAgB,SAAS,MAAwB;CAC/C,KAAK,MAAM,OAAO,MAAM;EACtB,IAAI,IAAI,SAAS,GAAG,GAClB,MAAM,IAAI,MAAM,kBAAkB,IAAI,0BAA0B;EAElE,IAAI,IAAI,SAAS,MACf,MAAM,IAAI,MAAM,kBAAkB,IAAI,+BAA+B;CAEzE;CACA,OAAO,CAAC,GAAG,IAAI,IAAI,IAAI,CAAC,CAAC,CAAC,KAAK,GAAG;AACpC"}

package/dist/cdn/purge-store.d.ts

@@ -0,0 +1,23 @@
+/**
+ * CDN purge handler singleton — same pattern as cache/handler-store.ts.
+ *
+ * Set via timber.config.ts or setCdnPurgeHandler() at boot. When set,
+ * cache.invalidate({ tag }) also triggers CDN purge for the invalidated
+ * tags, so revalidateTag() composes with CDN caching out of the box.
+ *
+ * See design/25-production-deployments.md §Layer 2.
+ */
+export interface CdnPurgeHandler {
+    /**
+     * Purge the given cache tags from the CDN.
+     * Called by cache.invalidate when a tag is invalidated.
+     */
+    purgeTags(tags: string[]): Promise<void>;
+}
+/** Install a CDN purge handler. Called by the framework at boot from timber.config.ts. */
+export declare function setCdnPurgeHandler(h: CdnPurgeHandler): void;
+/** Get the current CDN purge handler, if configured. */
+export declare function getCdnPurgeHandler(): CdnPurgeHandler | undefined;
+/** @internal — reset for tests only. */
+export declare function _resetCdnPurgeHandler(): void;
+//# sourceMappingURL=purge-store.d.ts.map

package/dist/cdn/purge-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"purge-store.d.ts","sourceRoot":"","sources":["../../src/cdn/purge-store.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,MAAM,WAAW,eAAe;IAC9B;;;OAGG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1C;AAID,0FAA0F;AAC1F,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,eAAe,GAAG,IAAI,CAE3D;AAED,wDAAwD;AACxD,wBAAgB,kBAAkB,IAAI,eAAe,GAAG,SAAS,CAEhE;AAED,wCAAwC;AACxC,wBAAgB,qBAAqB,IAAI,IAAI,CAE5C"}

package/dist/cdn/workers-cache-purge.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Cloudflare Workers Cache purge handler — purges by cache tag via
+ * ctx.cache.purge() on the ExecutionContext.
+ *
+ * Available on ALL Cloudflare plans (no Enterprise requirement).
+ * No API token needed — uses the Workers runtime's built-in cache API.
+ *
+ * ctx.cache.purge() operates on the same underlying Cloudflare CDN cache
+ * as caches.default — entries stored via cache.put() with matching
+ * Cache-Tag headers are purged (TIM-1172). See design/25 §TIM-1172.
+ *
+ * Auto-wired by the Cloudflare adapter when no user-configured CDN
+ * purge handler is set. Uses the Workers Cache ALS bridge to access
+ * ctx.cache from within the request context.
+ */
+import type { CdnPurgeHandler } from './purge-store.ts';
+export declare class WorkersCachePurge implements CdnPurgeHandler {
+    purgeTags(tags: string[]): Promise<void>;
+}
+//# sourceMappingURL=workers-cache-purge.d.ts.map

package/dist/cdn/workers-cache-purge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workers-cache-purge.d.ts","sourceRoot":"","sources":["../../src/cdn/workers-cache-purge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AAGxD,qBAAa,iBAAkB,YAAW,eAAe;IACjD,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAY7C;CACF"}

package/dist/cdn/workers-cache-purge.js

@@ -0,0 +1,35 @@
+import { u as workersCachePurgeAls } from "../_chunks/als-registry-DaxkVjt5.js";
+//#region src/server/workers-cache-bridge.ts
+/**
+* Per-request Workers Cache purge bridge — ALS bridge for Cloudflare adapter.
+*
+* The generated _worker.js wraps each request with `runWithWorkersCachePurge`,
+* binding `ctx.cache` from the Cloudflare ExecutionContext. The
+* `WorkersCachePurge` CDN purge handler reads from this ALS to call
+* `ctx.cache.purge({ tags })` without needing an API token.
+*
+* Design doc: design/06-caching.md, design/25-production-deployments.md
+*/
+/**
+* Get the current request's Workers Cache context, if available.
+*
+* Returns undefined outside a Cloudflare Workers request context
+* or on platforms without Workers Cache support.
+*/
+function getWorkersCachePurgeCtx() {
+	return workersCachePurgeAls.getStore();
+}
+//#endregion
+//#region src/cdn/workers-cache-purge.ts
+var WorkersCachePurge = class {
+	async purgeTags(tags) {
+		if (tags.length === 0) return;
+		const ctx = getWorkersCachePurgeCtx();
+		if (!ctx) throw new Error("WorkersCachePurge: no Workers Cache context available. This handler can only be used within a Cloudflare Workers request context.");
+		await ctx.purge({ tags });
+	}
+};
+//#endregion
+export { WorkersCachePurge };
+
+//# sourceMappingURL=workers-cache-purge.js.map

package/dist/cdn/workers-cache-purge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workers-cache-purge.js","names":[],"sources":["../../src/server/workers-cache-bridge.ts","../../src/cdn/workers-cache-purge.ts"],"sourcesContent":["/**\n * Per-request Workers Cache purge bridge — ALS bridge for Cloudflare adapter.\n *\n * The generated _worker.js wraps each request with `runWithWorkersCachePurge`,\n * binding `ctx.cache` from the Cloudflare ExecutionContext. The\n * `WorkersCachePurge` CDN purge handler reads from this ALS to call\n * `ctx.cache.purge({ tags })` without needing an API token.\n *\n * Design doc: design/06-caching.md, design/25-production-deployments.md\n */\n\nimport { workersCachePurgeAls } from './als-registry.ts';\nimport type { WorkersCachePurgeCtx } from './als-registry.ts';\n\n/**\n * Run a function with Workers Cache purge context available.\n *\n * Called by the generated Cloudflare _worker.js entry to bind\n * `ctx.cache` for the request duration.\n */\nexport function runWithWorkersCachePurge<T>(ctx: WorkersCachePurgeCtx, fn: () => T): T {\n  return workersCachePurgeAls.run(ctx, fn);\n}\n\n/**\n * Get the current request's Workers Cache context, if available.\n *\n * Returns undefined outside a Cloudflare Workers request context\n * or on platforms without Workers Cache support.\n */\nexport function getWorkersCachePurgeCtx(): WorkersCachePurgeCtx | undefined {\n  return workersCachePurgeAls.getStore();\n}\n","/**\n * Cloudflare Workers Cache purge handler — purges by cache tag via\n * ctx.cache.purge() on the ExecutionContext.\n *\n * Available on ALL Cloudflare plans (no Enterprise requirement).\n * No API token needed — uses the Workers runtime's built-in cache API.\n *\n * ctx.cache.purge() operates on the same underlying Cloudflare CDN cache\n * as caches.default — entries stored via cache.put() with matching\n * Cache-Tag headers are purged (TIM-1172). See design/25 §TIM-1172.\n *\n * Auto-wired by the Cloudflare adapter when no user-configured CDN\n * purge handler is set. Uses the Workers Cache ALS bridge to access\n * ctx.cache from within the request context.\n */\n\nimport type { CdnPurgeHandler } from './purge-store.ts';\nimport { getWorkersCachePurgeCtx } from '../server/workers-cache-bridge.ts';\n\nexport class WorkersCachePurge implements CdnPurgeHandler {\n  async purgeTags(tags: string[]): Promise<void> {\n    if (tags.length === 0) return;\n\n    const ctx = getWorkersCachePurgeCtx();\n    if (!ctx) {\n      throw new Error(\n        'WorkersCachePurge: no Workers Cache context available. ' +\n          'This handler can only be used within a Cloudflare Workers request context.'\n      );\n    }\n\n    await ctx.purge({ tags });\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AA8BA,SAAgB,0BAA4D;CAC1E,OAAO,qBAAqB,SAAS;AACvC;;;ACbA,IAAa,oBAAb,MAA0D;CACxD,MAAM,UAAU,MAA+B;EAC7C,IAAI,KAAK,WAAW,GAAG;EAEvB,MAAM,MAAM,wBAAwB;EACpC,IAAI,CAAC,KACH,MAAM,IAAI,MACR,mIAEF;EAGF,MAAM,IAAI,MAAM,EAAE,KAAK,CAAC;CAC1B;AACF"}

package/dist/cli-check.d.ts

@@ -0,0 +1,133 @@
+/**
+ * `timber check` — the implementation behind the CLI command.
+ *
+ * Two passes, in order:
+ *
+ * 1. **Routes.** Resolve the project through Vite — so root, `appDir`, and
+ *    `pageExtensions` are the ones `timber build` uses, including config
+ *    passed inline to `timber()` — then scan, run the convention linter, and
+ *    write the route codegen (`.timber/timber-routes.d.ts`,
+ *    `.timber/segment-types.d.ts`, `timber-env.d.ts`).
+ *
+ *    Codegen runs *before* the type pass on purpose: those
+ *    files are what give `<Link href>`, `useSegmentParams()` and
+ *    `MiddlewareContext` their per-route types (design/09-typescript.md
+ *    §"Typed Routes"), and they are build artifacts — a fresh clone that has
+ *    never run `timber dev` or `timber build` does not have them, so a type
+ *    pass on its own would report errors about correct code. A clone whose
+ *    routes changed since the last build has the same problem with stale ones.
+ * 2. **Types.** `tsgo --noEmit` over the project.
+ *
+ * tsgo is spawned as `node <@typescript/native-preview>/lib/tsgo.js`, never as
+ * a bare `tsgo` off PATH — the package is an *optional peer dependency*, so
+ * there is no reason for its shim to be on a user's PATH, and the shim is a
+ * `.cmd` on Windows which cannot be spawned without a shell. `shell: true`
+ * would then concatenate the argv into an unescaped command string, so a
+ * project path containing a space would break on exactly the platform the
+ * shell was there to support. This mirrors `scripts/build-types.js`, whose
+ * header comment is the specification for the pattern.
+ *
+ * Design docs: 11-platform.md §CLI, 09-typescript.md, 28-npm-packaging.md
+ */
+import { type ResolveViteConfig } from './cli-context.ts';
+/**
+ * Run the compiler to completion.
+ *
+ * Resolves with its exit status (`null` when a signal killed it) and rejects
+ * only when the process could not be started — the two outcomes `runTypeCheck`
+ * has to keep apart. The seam is this narrow on purpose: a test double is a
+ * plain async function, with no `ChildProcess` shape to imitate.
+ */
+export type RunTsgo = (command: string, args: string[], cwd: string) => Promise<number | null>;
+/**
+ * Run the compiler and capture its stdout — used for `--showConfig`, whose
+ * output is data we read rather than diagnostics the user reads.
+ */
+export type ReadTsgoConfig = (command: string, args: string[], cwd: string) => Promise<string>;
+/** @internal Dependency injection for testing. */
+export interface CheckDeps {
+    /**
+     * Resolve tsgo's own JS entry point. Throws when the package is not
+     * installed — the caller turns that into an install instruction.
+     */
+    resolveTsgoEntry?: () => string;
+    runTsgo?: RunTsgo;
+    readTsgoConfig?: ReadTsgoConfig;
+    resolveViteConfig?: ResolveViteConfig;
+}
+export interface CheckOptions {
+    /** Project root, for resolving tsgo. Defaults to `process.cwd()`. */
+    root?: string;
+    /**
+     * Path to a **tsconfig**, forwarded to tsgo as `--project` and sourced from
+     * the CLI's own `--project`. The route pass takes no part in it: it resolves
+     * the app's configuration through Vite, as `timber build` does.
+     */
+    config?: string;
+}
+/**
+ * Locate `@typescript/native-preview`'s JS entry.
+ *
+ * Resolution is attempted from this package first (it is declared an optional
+ * peer dependency, so a package manager links it here when the user installs
+ * it) and then from the project root (covering a hoisted install, or a user who
+ * added it without the peer link). Throws if neither finds it.
+ */
+export declare function resolveTsgoEntry(root: string, resolveFrom?: (from: string, specifier: string) => string): string;
+/** What the route pass needs from the command line. */
+export interface RouteOptions {
+    /**
+     * Path to a **Vite** config file, from `--config`. Undefined means Vite's own
+     * discovery, the same as `timber dev`/`build` without the flag. A project
+     * that builds with a custom Vite config has to be checkable with it too, or
+     * `check` resolves a different app than `build` does (TIM-1332, round 4).
+     */
+    viteConfigFile?: string;
+}
+/** Everything the route scan needs, as the build itself resolves it. */
+export interface RouteInputs {
+    root: string;
+    appDir: string;
+    pageExtensions: string[] | undefined;
+}
+/**
+ * Resolve root, appDir and pageExtensions the way `timber build` resolves them
+ * — through Vite, never by re-reading `timber.config.ts` (see `cli-context.ts`).
+ * Inline `timber({ pageExtensions: [...] })` is the case that bites: a scan
+ * that re-read the file would silently use default page extensions and write a
+ * route map missing the app's pages. `examples/next-playground-migration` is
+ * exactly this shape.
+ */
+export declare function resolveRouteInputs(options?: RouteOptions, deps?: CheckDeps): Promise<RouteInputs>;
+/**
+ * Resolve the app directory, scan it, fail on proven-fatal route
+ * misconfigurations, print warnings, and write the route codegen the type pass
+ * depends on.
+ *
+ * Error-level lint findings throw rather than print, matching what
+ * `plugins/routing.ts` does at build time: the tree is not fit to publish, so
+ * it must not reach codegen either. Warnings are printed and do not fail the
+ * command — same severity contract as dev and build, so `timber check` cannot
+ * disagree with them about what a valid app is.
+ */
+export declare function checkRoutes(options?: RouteOptions, deps?: CheckDeps): Promise<RouteInputs>;
+/**
+ * Verify that the import specifiers in the generated route types resolve on the
+ * filesystem. A `.d.ts` whose import fails does NOT produce a TypeScript error —
+ * every type that depends on it silently becomes `any`. The generated file
+ * contains type-level `_AssertSchemaNotAny` / `_AssertCodecTypeNotAny` guards
+ * that catch this at typecheck time, but a diagnostic here fires earlier and
+ * names the exact import that is broken rather than leaving the user to decode
+ * a constraint error.
+ */
+export declare function verifyCodegenImports(root: string): void;
+/**
+ * Run `tsgo --noEmit`, streaming its output.
+ *
+ * Rejects with the real numeric exit status on type errors. A failure to *start*
+ * the compiler is reported separately — the historical bug this replaces
+ * surfaced ENOENT as "Type check failed with exit code undefined", which read
+ * as a type error and sent users looking at their own code.
+ */
+export declare function runTypeCheck(options?: CheckOptions, deps?: CheckDeps): Promise<void>;
+//# sourceMappingURL=cli-check.d.ts.map

package/dist/cli-check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-check.d.ts","sourceRoot":"","sources":["../src/cli-check.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAQH,OAAO,EAAwB,KAAK,iBAAiB,EAAE,MAAM,kBAAkB,CAAC;AAahF;;;;;;;GAOG;AACH,MAAM,MAAM,OAAO,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAAC;AAE/F;;;GAGG;AACH,MAAM,MAAM,cAAc,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,GAAG,EAAE,MAAM,KAAK,OAAO,CAAC,MAAM,CAAC,CAAC;AAE/F,kDAAkD;AAClD,MAAM,WAAW,SAAS;IACxB;;;OAGG;IACH,gBAAgB,CAAC,EAAE,MAAM,MAAM,CAAC;IAChC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,cAAc,CAAC,EAAE,cAAc,CAAC;IAChC,iBAAiB,CAAC,EAAE,iBAAiB,CAAC;CACvC;AAED,MAAM,WAAW,YAAY;IAC3B,qEAAqE;IACrE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,MAAM,EACZ,WAAW,GAAE,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,KAAK,MACV,GACvC,MAAM,CAwBR;AAED,uDAAuD;AACvD,MAAM,WAAW,YAAY;IAC3B;;;;;OAKG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAED,wEAAwE;AACxE,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,cAAc,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;CACtC;AAED;;;;;;;GAOG;AACH,wBAAsB,kBAAkB,CACtC,OAAO,GAAE,YAAiB,EAC1B,IAAI,GAAE,SAAc,GACnB,OAAO,CAAC,WAAW,CAAC,CAGtB;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,WAAW,CAC/B,OAAO,GAAE,YAAiB,EAC1B,IAAI,GAAE,SAAc,GACnB,OAAO,CAAC,WAAW,CAAC,CAiCtB;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAmCvD;AAqGD;;;;;;;GAOG;AACH,wBAAsB,YAAY,CAChC,OAAO,GAAE,YAAiB,EAC1B,IAAI,GAAE,SAAc,GACnB,OAAO,CAAC,IAAI,CAAC,CAiDf"}

package/dist/cli-context.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Resolve timber's configuration the way `timber build` resolves it, for CLI
+ * commands that run outside the build: `timber check` and `timber preview`.
+ *
+ * Reading `timber.config.ts` directly is **not** equivalent, which is the whole
+ * reason this goes through Vite (TIM-1332, review round 3; TIM-1531):
+ *
+ * - Config passed inline — `timber({ pageExtensions, adapter, output })` in
+ *   `vite.config.ts` — lives only in the plugin's closure. Nothing that
+ *   re-reads the config file can see it.
+ * - `root` is Vite's resolved root, not the caller's cwd, and the two differ in
+ *   the monorepo layouts TIM-498 describes.
+ * - The build directory can come from Vite's `build.outDir`, which only a
+ *   resolved Vite config knows.
+ * - `--config` names a Vite config file; only Vite can load it.
+ *
+ * There is no fallback to a second, hand-rolled resolution. A project whose
+ * Vite config does not produce the timber plugin cannot be built either, so a
+ * command that quietly proceeded on a guess would act on an app that does not
+ * exist.
+ *
+ * Design docs: 11-platform.md §CLI
+ */
+import { type PluginContext } from './plugin-context.ts';
+/** The subset of a resolved Vite plugin this module reads. */
+export interface PluginWithApi {
+    name: string;
+    api?: unknown;
+}
+/**
+ * Vite's own `resolveConfig`, narrowed to what this module passes and reads.
+ *
+ * The seam sits at `resolveConfig` rather than at "give me the plugins" so the
+ * *arguments* are the thing under test: which config file, which command, and
+ * which mode defaults. Those arguments have been wrong three separate times
+ * (TIM-1332 rounds 4-6), and a double that answered "here are the plugins"
+ * could not see any of it. The double returns what Vite returns — plugins with
+ * an opaque `api` — so the lookup and narrowing under test stay the real ones.
+ */
+export type ResolveViteConfig = (inlineConfig: {
+    configFile: string | undefined;
+}, command: 'build', defaultMode: string, defaultNodeEnv: string) => Promise<{
+    plugins: readonly PluginWithApi[];
+}>;
+/**
+ * Resolve the project through Vite and return timber's context as
+ * `timber build` would see it.
+ *
+ * @param command The CLI command asking, named in the error message.
+ * @param viteConfigFile `--config`. Undefined means Vite's own discovery, the
+ *   same as `timber build` without the flag.
+ */
+export declare function resolveTimberContext(command: string, viteConfigFile: string | undefined, resolveViteConfig?: ResolveViteConfig): Promise<PluginContext>;
+//# sourceMappingURL=cli-context.d.ts.map

package/dist/cli-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli-context.d.ts","sourceRoot":"","sources":["../src/cli-context.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAqB,KAAK,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAK5E,8DAA8D;AAC9D,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,OAAO,CAAC;CACf;AAED;;;;;;;;;GASG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAC9B,YAAY,EAAE;IAAE,UAAU,EAAE,MAAM,GAAG,SAAS,CAAA;CAAE,EAChD,OAAO,EAAE,OAAO,EAChB,WAAW,EAAE,MAAM,EACnB,cAAc,EAAE,MAAM,KACnB,OAAO,CAAC;IAAE,OAAO,EAAE,SAAS,aAAa,EAAE,CAAA;CAAE,CAAC,CAAC;AAkCpD;;;;;;;GAOG;AACH,wBAAsB,oBAAoB,CACxC,OAAO,EAAE,MAAM,EACf,cAAc,EAAE,MAAM,GAAG,SAAS,EAClC,iBAAiB,GAAE,iBAA4C,GAC9D,OAAO,CAAC,aAAa,CAAC,CAsBxB"}