@timber-js/app 0.2.0-alpha.10 → 0.2.0-alpha.100

package/dist/_chunks/define-CfBPoJb0.js

@@ -0,0 +1,123 @@
+import { a as validateSync, i as isStandardSchema, r as isCodec } from "./schema-bridge-Cxu4l-7p.js";
+//#region src/segment-params/define.ts
+var _getSegmentParamsFn;
+var _useSegmentParamsHook;
+/**
+* Register the client useSegmentParams hook.
+* Called by client entry at module load time to avoid require() at call time.
+* @internal
+*/
+function _registerUseSegmentParams(hook) {
+	_useSegmentParamsHook = hook;
+}
+if (typeof window !== "undefined" && !_useSegmentParamsHook) import("./use-segment-params-BkpKAQ7D.js").then((n) => n.r).then((mod) => {
+	if (!_useSegmentParamsHook) _useSegmentParamsHook = mod.useSegmentParams;
+});
+/**
+* Register the getSegmentParams function. Called once at module load time
+* from request-context.ts to avoid dynamic import at call time.
+* @internal
+*/
+function _setGetSegmentParamsFn(fn) {
+	_getSegmentParamsFn = fn;
+}
+function getSegmentParamsFromAls() {
+	if (!_getSegmentParamsFn) throw new Error("[timber] segmentParams.get() is only available on the server. Use segmentParams.useSegmentParams() on the client.");
+	return _getSegmentParamsFn();
+}
+/**
+* Wrap a Standard Schema into a Codec for route params.
+*
+* Unlike fromSchema for search params:
+* - Parse throws on failure (no fallback to default)
+* - Serialize returns string (not null)
+*/
+function fromParamSchema(fieldName, schema) {
+	return {
+		parse(value) {
+			const result = validateSync(schema, Array.isArray(value) ? value : value);
+			if (!result.issues) return result.value;
+			const messages = result.issues.map((i) => i.message).join(", ");
+			throw new Error(`[timber] Param '${fieldName}' coercion failed: ${messages}`);
+		},
+		serialize(value) {
+			if (value === null || value === void 0) return null;
+			if (Array.isArray(value)) return value.join("/");
+			return String(value);
+		}
+	};
+}
+/**
+* Resolve a field value to a Codec. Auto-detects Standard Schema objects.
+*/
+function resolveField(fieldName, value) {
+	if (isCodec(value)) return value;
+	if (isStandardSchema(value)) return fromParamSchema(fieldName, value);
+	throw new Error(`[timber] defineSegmentParams: field '${fieldName}' is not a valid codec or Standard Schema. Expected an object with { parse, serialize } methods, or a Standard Schema object (Zod, Valibot, ArkType).`);
+}
+/**
+* Validate that no codec's serialize returns null.
+* Route params are structural — they must produce a valid path segment.
+*/
+function validateSerialize(codecMap) {
+	for (const [key, codec] of Object.entries(codecMap)) try {
+		const testValue = codec.parse("test");
+		if (codec.serialize(testValue) === null) throw new Error(`[timber] defineSegmentParams: field '${key}' codec.serialize() returned null.\n  Route params are path segments — they cannot be omitted.\n  Ensure serialize() always returns a string.`);
+	} catch (e) {
+		if (e instanceof Error && e.message.includes("returned null")) throw e;
+	}
+}
+/**
+* Create a ParamsDefinition from a map of codecs and/or Standard Schema objects.
+*
+* ```ts
+* // app/products/[id]/layout.tsx
+* import { defineSegmentParams } from '@timber-js/app/segment-params'
+* import { z } from 'zod/v4'
+*
+* export const segmentParams = defineSegmentParams({
+*   id: z.coerce.number().int().positive(),
+* })
+* ```
+*/
+function defineSegmentParams(codecs) {
+	const resolvedCodecs = {};
+	for (const [key, value] of Object.entries(codecs)) resolvedCodecs[key] = resolveField(key, value);
+	validateSerialize(resolvedCodecs);
+	function parse(raw) {
+		const result = {};
+		for (const [key, codec] of Object.entries(resolvedCodecs)) {
+			const rawValue = raw[key];
+			result[key] = codec.parse(rawValue);
+		}
+		return result;
+	}
+	function serialize(values) {
+		const result = {};
+		for (const [key, codec] of Object.entries(resolvedCodecs)) {
+			const serialized = codec.serialize(values[key]);
+			if (serialized === null) throw new Error(`[timber] params.serialize: field '${key}' serialized to null. Route params must produce a valid path segment.`);
+			result[key] = serialized;
+		}
+		return result;
+	}
+	function get() {
+		if (typeof window !== "undefined") throw new Error("[timber] segmentParams.get() is server-only. Use segmentParams.useSegmentParams() on the client.");
+		return getSegmentParamsFromAls();
+	}
+	function useSegmentParams() {
+		if (!_useSegmentParamsHook) throw new Error("[timber] segmentParams.useSegmentParams() requires @timber-js/app/client to be loaded. This hook can only be used in client components.");
+		return _useSegmentParamsHook();
+	}
+	return {
+		parse,
+		serialize,
+		get,
+		useSegmentParams,
+		codecs: resolvedCodecs
+	};
+}
+//#endregion
+export { _setGetSegmentParamsFn as n, defineSegmentParams as r, _registerUseSegmentParams as t };
+
+//# sourceMappingURL=define-CfBPoJb0.js.map

package/dist/_chunks/define-CfBPoJb0.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"define-CfBPoJb0.js","names":[],"sources":["../../src/segment-params/define.ts"],"sourcesContent":["/**\n * defineSegmentParams — factory for typed route param coercion.\n *\n * Creates a ParamsDefinition that coerces raw string params from the\n * URL into typed values. Used by exporting from params.ts (segment-level)\n * convention file.\n *\n * Reuses the shared Codec<T> protocol with Standard Schema auto-detection,\n * same pattern as defineSearchParams. Runtime constraints are stricter:\n * - serialize must return string (not null — path segments can't be omitted)\n * - parse throwing → 404 (invalid param value)\n *\n * Design doc: design/07a-route-params-triage.md\n */\n\nimport type { Codec } from '../codec.js';\nimport {\n  type StandardSchemaV1,\n  validateSync,\n  isStandardSchema,\n  isCodec,\n} from '../schema-bridge.js';\n\n// ---------------------------------------------------------------------------\n// Server-only ALS reference for .get()\n// ---------------------------------------------------------------------------\n\n// Same pattern as search-params: eagerly registered at server startup\n// to avoid dynamic imports that lose ALS context. See TIM-523.\nlet _getSegmentParamsFn: (() => Record<string, string | string[]>) | undefined;\nlet _useSegmentParamsHook: (() => Record<string, string | string[]>) | undefined;\n\n/**\n * Register the client useSegmentParams hook.\n * Called by client entry at module load time to avoid require() at call time.\n * @internal\n */\nexport function _registerUseSegmentParams(hook: () => Record<string, string | string[]>): void {\n  _useSegmentParamsHook = hook;\n}\n\n// Self-register on the client when the barrel hasn't been imported yet.\n// Handles the edge case where a client component imports only from params.ts\n// without importing anything from @timber-js/app/client (which runs the\n// registration). The dynamic import resolves before React hydration in Vite.\nif (typeof window !== 'undefined' && !_useSegmentParamsHook) {\n  import('../client/use-segment-params.js').then((mod) => {\n    if (!_useSegmentParamsHook) {\n      _useSegmentParamsHook = mod.useSegmentParams;\n    }\n  });\n}\n\n/**\n * Register the getSegmentParams function. Called once at module load time\n * from request-context.ts to avoid dynamic import at call time.\n * @internal\n */\nexport function _setGetSegmentParamsFn(fn: () => Record<string, string | string[]>): void {\n  _getSegmentParamsFn = fn;\n}\n\nfunction getSegmentParamsFromAls(): Record<string, string | string[]> {\n  if (!_getSegmentParamsFn) {\n    throw new Error(\n      '[timber] segmentParams.get() is only available on the server. ' +\n        'Use segmentParams.useSegmentParams() on the client.'\n    );\n  }\n  return _getSegmentParamsFn();\n}\n\n// ---------------------------------------------------------------------------\n// Types\n// ---------------------------------------------------------------------------\n\n/** Infer the output type from a Codec or StandardSchemaV1. */\nexport type InferParamField<V> =\n  V extends Codec<infer T> ? T : V extends StandardSchemaV1<infer T> ? T : never;\n\n/** Acceptable field value for defineParams: a Codec or a Standard Schema. */\nexport type ParamField<T = unknown> = Codec<T> | StandardSchemaV1<T>;\n\nexport type { StandardSchemaV1 };\n\n/**\n * A typed route params definition.\n *\n * Returned by defineParams(). Provides parse (string → typed) and\n * serialize (typed → string) for each declared param.\n */\nexport interface ParamsDefinition<T extends Record<string, unknown>> {\n  /** Parse raw string params into typed values. Throws on invalid values. */\n  parse(raw: Record<string, string | string[]>): T;\n\n  /** Serialize typed values back to strings for URL construction. */\n  serialize(values: T): Record<string, string>;\n\n  /**\n   * Get typed segment params from the current request context (ALS).\n   *\n   * Server-only, sync.\n   *\n   * ```ts\n   * // app/products/[id]/params.ts\n   * export const segmentParams = defineSegmentParams({ id: z.coerce.number() })\n   *\n   * // app/products/[id]/page.tsx\n   * import { segmentParams } from './params'\n   * export default function Page() {\n   *   const { id } = segmentParams.get() // id: number\n   * }\n   * ```\n   */\n  get(): T;\n\n  /**\n   * Client hook for accessing typed segment params reactively.\n   *\n   * ```tsx\n   * 'use client'\n   * import { segmentParams } from './params'\n   * export function ProductHeader() {\n   *   const { id } = segmentParams.useSegmentParams()\n   * }\n   * ```\n   */\n  useSegmentParams(): T;\n\n  /** Read-only codec map. */\n  codecs: { [K in keyof T]: Codec<T[K]> };\n}\n\n// ---------------------------------------------------------------------------\n// Internal helpers\n// ---------------------------------------------------------------------------\n\n/**\n * Wrap a Standard Schema into a Codec for route params.\n *\n * Unlike fromSchema for search params:\n * - Parse throws on failure (no fallback to default)\n * - Serialize returns string (not null)\n */\nfunction fromParamSchema<T>(fieldName: string, schema: StandardSchemaV1<T>): Codec<T> {\n  return {\n    parse(value: string | string[] | undefined): T {\n      // Route params are always strings (single segment) or string[] (catch-all)\n      const input = Array.isArray(value) ? value : value;\n\n      const result = validateSync(schema, input);\n      if (!result.issues) {\n        return result.value;\n      }\n\n      // For route params, parse failure means the param is invalid → throw\n      const messages = result.issues.map((i) => i.message).join(', ');\n      throw new Error(`[timber] Param '${fieldName}' coercion failed: ${messages}`);\n    },\n\n    serialize(value: T): string | null {\n      if (value === null || value === undefined) {\n        return null;\n      }\n      // Catch-all segments produce arrays — join with '/' for path reconstruction\n      if (Array.isArray(value)) {\n        return value.join('/');\n      }\n      return String(value);\n    },\n  };\n}\n\n/**\n * Resolve a field value to a Codec. Auto-detects Standard Schema objects.\n */\nfunction resolveField(fieldName: string, value: ParamField): Codec<unknown> {\n  if (isCodec(value)) {\n    return value;\n  }\n\n  if (isStandardSchema(value)) {\n    return fromParamSchema(fieldName, value);\n  }\n\n  throw new Error(\n    `[timber] defineSegmentParams: field '${fieldName}' is not a valid codec or Standard Schema. ` +\n      `Expected an object with { parse, serialize } methods, or a Standard Schema object ` +\n      `(Zod, Valibot, ArkType).`\n  );\n}\n\n/**\n * Validate that no codec's serialize returns null.\n * Route params are structural — they must produce a valid path segment.\n */\nfunction validateSerialize(codecMap: Record<string, Codec<unknown>>): void {\n  for (const [key, codec] of Object.entries(codecMap)) {\n    // Test serialize with a sample parsed value to check for null\n    // We can't exhaustively test, but we can check that serialize(parse(\"test\"))\n    // doesn't return null for a basic input.\n    try {\n      const testValue = codec.parse('test');\n      const serialized = codec.serialize(testValue);\n      if (serialized === null) {\n        throw new Error(\n          `[timber] defineSegmentParams: field '${key}' codec.serialize() returned null.\\n` +\n            `  Route params are path segments — they cannot be omitted.\\n` +\n            `  Ensure serialize() always returns a string.`\n        );\n      }\n    } catch (e) {\n      // parse('test') may throw for strict codecs (e.g., number-only).\n      // That's fine — it means the codec validates. We only care about\n      // serialize returning null, which we can't test without a valid value.\n      if (e instanceof Error && e.message.includes('returned null')) {\n        throw e;\n      }\n    }\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Factory\n// ---------------------------------------------------------------------------\n\n/**\n * Create a ParamsDefinition from a map of codecs and/or Standard Schema objects.\n *\n * ```ts\n * // app/products/[id]/layout.tsx\n * import { defineSegmentParams } from '@timber-js/app/segment-params'\n * import { z } from 'zod/v4'\n *\n * export const segmentParams = defineSegmentParams({\n *   id: z.coerce.number().int().positive(),\n * })\n * ```\n */\nexport function defineSegmentParams<C extends Record<string, ParamField>>(\n  codecs: C\n): ParamsDefinition<{ [K in keyof C]: InferParamField<C[K]> }> {\n  type T = { [K in keyof C]: InferParamField<C[K]> };\n\n  const resolvedCodecs: Record<string, Codec<unknown>> = {};\n\n  for (const [key, value] of Object.entries(codecs)) {\n    resolvedCodecs[key] = resolveField(key, value as ParamField);\n  }\n\n  // Validate that serialize doesn't return null\n  validateSerialize(resolvedCodecs);\n\n  // ---- parse ----\n  function parse(raw: Record<string, string | string[]>): T {\n    const result: Record<string, unknown> = {};\n\n    for (const [key, codec] of Object.entries(resolvedCodecs)) {\n      const rawValue = raw[key];\n      // Route params are always present (the route matched)\n      result[key] = codec.parse(rawValue);\n    }\n\n    return result as T;\n  }\n\n  // ---- serialize ----\n  function serialize(values: T): Record<string, string> {\n    const result: Record<string, string> = {};\n\n    for (const [key, codec] of Object.entries(resolvedCodecs)) {\n      const serialized = codec.serialize(values[key as keyof T] as unknown);\n      if (serialized === null) {\n        throw new Error(\n          `[timber] params.serialize: field '${key}' serialized to null. ` +\n            `Route params must produce a valid path segment.`\n        );\n      }\n      result[key] = serialized;\n    }\n\n    return result;\n  }\n\n  // ---- get ----\n  // ALS-backed: reads segment params from the current request context.\n  // Server-only, sync.\n  //\n  // The pipeline already coerces params via coerceSegmentParams() which\n  // calls parse() and stores typed values in ALS via setSegmentParams().\n  // We return those directly instead of re-parsing, because codecs may\n  // not be idempotent (e.g., a codec that only accepts raw strings would\n  // throw if given an already-parsed value). See TIM-574.\n  function get(): T {\n    if (typeof window !== 'undefined') {\n      throw new Error(\n        '[timber] segmentParams.get() is server-only. ' +\n          'Use segmentParams.useSegmentParams() on the client.'\n      );\n    }\n    const params = getSegmentParamsFromAls();\n    // params are already coerced by the pipeline — return as-is.\n    return params as unknown as T;\n  }\n\n  // ---- useSegmentParams ----\n  // Client hook that reads typed params from the navigation context.\n  // Delegates to the existing useSegmentParams hook from use-segment-params.ts.\n  function useSegmentParams(): T {\n    if (!_useSegmentParamsHook) {\n      throw new Error(\n        '[timber] segmentParams.useSegmentParams() requires @timber-js/app/client to be loaded. ' +\n          'This hook can only be used in client components.'\n      );\n    }\n    const raw = _useSegmentParamsHook();\n    // Params are already coerced by the server pipeline before being sent\n    // to the client — return as-is. Re-parsing would break non-idempotent\n    // codecs (e.g., z.coerce.number() on an already-parsed number). See TIM-574.\n    return raw as unknown as T;\n  }\n\n  const definition: ParamsDefinition<T> = {\n    parse,\n    serialize,\n    get,\n    useSegmentParams,\n    codecs: resolvedCodecs as { [K in keyof T]: Codec<T[K]> },\n  };\n\n  return definition;\n}\n"],"mappings":";;AA6BA,IAAI;AACJ,IAAI;;;;;;AAOJ,SAAgB,0BAA0B,MAAqD;AAC7F,yBAAwB;;AAO1B,IAAI,OAAO,WAAW,eAAe,CAAC,sBACpC,QAAO,oCAAA,MAAA,MAAA,EAAA,EAAA,CAAmC,MAAM,QAAQ;AACtD,KAAI,CAAC,sBACH,yBAAwB,IAAI;EAE9B;;;;;;AAQJ,SAAgB,uBAAuB,IAAmD;AACxF,uBAAsB;;AAGxB,SAAS,0BAA6D;AACpE,KAAI,CAAC,oBACH,OAAM,IAAI,MACR,oHAED;AAEH,QAAO,qBAAqB;;;;;;;;;AA2E9B,SAAS,gBAAmB,WAAmB,QAAuC;AACpF,QAAO;EACL,MAAM,OAAyC;GAI7C,MAAM,SAAS,aAAa,QAFd,MAAM,QAAQ,MAAM,GAAG,QAAQ,MAEH;AAC1C,OAAI,CAAC,OAAO,OACV,QAAO,OAAO;GAIhB,MAAM,WAAW,OAAO,OAAO,KAAK,MAAM,EAAE,QAAQ,CAAC,KAAK,KAAK;AAC/D,SAAM,IAAI,MAAM,mBAAmB,UAAU,qBAAqB,WAAW;;EAG/E,UAAU,OAAyB;AACjC,OAAI,UAAU,QAAQ,UAAU,KAAA,EAC9B,QAAO;AAGT,OAAI,MAAM,QAAQ,MAAM,CACtB,QAAO,MAAM,KAAK,IAAI;AAExB,UAAO,OAAO,MAAM;;EAEvB;;;;;AAMH,SAAS,aAAa,WAAmB,OAAmC;AAC1E,KAAI,QAAQ,MAAM,CAChB,QAAO;AAGT,KAAI,iBAAiB,MAAM,CACzB,QAAO,gBAAgB,WAAW,MAAM;AAG1C,OAAM,IAAI,MACR,wCAAwC,UAAU,uJAGnD;;;;;;AAOH,SAAS,kBAAkB,UAAgD;AACzE,MAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,SAAS,CAIjD,KAAI;EACF,MAAM,YAAY,MAAM,MAAM,OAAO;AAErC,MADmB,MAAM,UAAU,UAAU,KAC1B,KACjB,OAAM,IAAI,MACR,wCAAwC,IAAI,+IAG7C;UAEI,GAAG;AAIV,MAAI,aAAa,SAAS,EAAE,QAAQ,SAAS,gBAAgB,CAC3D,OAAM;;;;;;;;;;;;;;;;AAuBd,SAAgB,oBACd,QAC6D;CAG7D,MAAM,iBAAiD,EAAE;AAEzD,MAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,OAAO,CAC/C,gBAAe,OAAO,aAAa,KAAK,MAAoB;AAI9D,mBAAkB,eAAe;CAGjC,SAAS,MAAM,KAA2C;EACxD,MAAM,SAAkC,EAAE;AAE1C,OAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,eAAe,EAAE;GACzD,MAAM,WAAW,IAAI;AAErB,UAAO,OAAO,MAAM,MAAM,SAAS;;AAGrC,SAAO;;CAIT,SAAS,UAAU,QAAmC;EACpD,MAAM,SAAiC,EAAE;AAEzC,OAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,eAAe,EAAE;GACzD,MAAM,aAAa,MAAM,UAAU,OAAO,KAA2B;AACrE,OAAI,eAAe,KACjB,OAAM,IAAI,MACR,qCAAqC,IAAI,uEAE1C;AAEH,UAAO,OAAO;;AAGhB,SAAO;;CAYT,SAAS,MAAS;AAChB,MAAI,OAAO,WAAW,YACpB,OAAM,IAAI,MACR,mGAED;AAIH,SAFe,yBAAyB;;CAQ1C,SAAS,mBAAsB;AAC7B,MAAI,CAAC,sBACH,OAAM,IAAI,MACR,0IAED;AAMH,SAJY,uBAAuB;;AAerC,QARwC;EACtC;EACA;EACA;EACA;EACA,QAAQ;EACT"}

package/dist/_chunks/define-cookie-BjpIt4UC.js

@@ -0,0 +1,194 @@
+//#region src/cookies/define-cookie.ts
+var _serverImpl;
+var _clientImpl;
+var _fromSchemaFn;
+/**
+* Register the server-side cookie implementation.
+* Called by server entry at module load time.
+* @internal
+*/
+function _registerServerCookieImpl(impl) {
+	_serverImpl = impl;
+}
+/**
+* Register the fromSchema bridge function.
+* Called by server/client entry at module load time.
+* @internal
+*/
+function _registerFromSchema(fn) {
+	_fromSchemaFn = fn;
+}
+var _useCookieModule;
+function getUseCookieModule() {
+	if (!_useCookieModule) throw new Error("[timber] defineCookie().useCookie() requires @timber-js/app/client to be loaded. This hook can only be used in client components.");
+	return _useCookieModule;
+}
+/**
+* Register the client cookie module. Called by the client entry to wire
+* up the lazy reference without a top-level import.
+*
+* @internal — framework use only
+*/
+function _registerUseCookieModule(mod) {
+	_useCookieModule = mod;
+	_clientImpl = {
+		useCookie: mod.useCookie,
+		getCookieValue: (name) => {
+			if (typeof document === "undefined") return void 0;
+			const match = document.cookie.match(new RegExp("(?:^|;\\s*)" + name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&") + "\\s*=\\s*([^;]*)"));
+			return match ? decodeURIComponent(match[1]) : void 0;
+		},
+		setCookieValue: (name, value, options) => {
+			const parts = [`${name}=${encodeURIComponent(value)}`];
+			const path = options?.path ?? "/";
+			parts.push(`Path=${path}`);
+			if (options?.domain) parts.push(`Domain=${options.domain}`);
+			if (options?.maxAge !== void 0) parts.push(`Max-Age=${options.maxAge}`);
+			if (options?.expires) parts.push(`Expires=${options.expires.toUTCString()}`);
+			const sameSite = options?.sameSite ?? "lax";
+			parts.push(`SameSite=${sameSite.charAt(0).toUpperCase()}${sameSite.slice(1)}`);
+			if (options?.secure) parts.push("Secure");
+			document.cookie = parts.join("; ");
+			mod.notifyCookieChange(name);
+		},
+		deleteCookieValue: (name, options) => {
+			const path = options?.path ?? "/";
+			const domain = options?.domain;
+			let cookieStr = `${name}=; Max-Age=0; Expires=Thu, 01 Jan 1970 00:00:00 GMT; Path=${path}`;
+			if (domain) cookieStr += `; Domain=${domain}`;
+			document.cookie = cookieStr;
+			mod.notifyCookieChange(name);
+		}
+	};
+}
+function resolveCodec(codecOrSchema) {
+	if (typeof codecOrSchema.parse === "function" && typeof codecOrSchema.serialize === "function") return codecOrSchema;
+	if (typeof codecOrSchema === "object" && codecOrSchema !== null && "~standard" in codecOrSchema) {
+		if (!_fromSchemaFn) throw new Error("[timber] defineCookie: Standard Schema auto-detection requires @timber-js/app/server or @timber-js/app/client to be loaded. Pass an explicit Codec<T> with parse/serialize methods, or ensure the framework entry module is imported.");
+		return _fromSchemaFn(codecOrSchema);
+	}
+	throw new Error("[timber] defineCookie: codec must be a Codec<T> (with parse/serialize methods) or a Standard Schema object (Zod, Valibot, ArkType).");
+}
+/**
+* Define a typed cookie.
+*
+* ```ts
+* import { defineCookie } from '@timber-js/app/cookies';
+* import { z } from 'zod/v4';
+*
+* // httpOnly: false — client methods available
+* export const themeCookie = defineCookie('theme', {
+*   codec: z.enum(['light', 'dark', 'system']).default('system'),
+*   httpOnly: false,
+*   maxAge: 60 * 60 * 24 * 365,
+* });
+*
+* // Server or client
+* const theme = themeCookie.get();
+* themeCookie.set('dark');
+*
+* // Client hook
+* const [theme, setTheme] = themeCookie.useCookie();
+*
+* // httpOnly: true (default) — server-only, no client methods
+* export const sessionCookie = defineCookie('session', {
+*   codec: z.string(),
+* });
+* sessionCookie.get();       // works on server
+* sessionCookie.useCookie(); // TS error — httpOnly cookie
+* ```
+*/
+function defineCookie(name, options) {
+	const { codec: codecOrSchema, ...cookieOpts } = options;
+	const codec = resolveCodec(codecOrSchema);
+	const resolvedOptions = { ...cookieOpts };
+	const isHttpOnly = options.httpOnly !== false;
+	function getClientOpts() {
+		return {
+			path: resolvedOptions.path,
+			domain: resolvedOptions.domain,
+			maxAge: resolvedOptions.maxAge,
+			expires: resolvedOptions.expires,
+			sameSite: resolvedOptions.sameSite,
+			secure: resolvedOptions.secure
+		};
+	}
+	function assertNotHttpOnlyClient(method) {
+		if (isHttpOnly && !_serverImpl) throw new Error(`[timber] defineCookie('${name}').${method}() cannot be used with httpOnly cookies — the browser cannot access them. Set httpOnly: false to enable client access.`);
+	}
+	const base = {
+		name,
+		options: resolvedOptions,
+		codec,
+		get() {
+			if (_serverImpl) {
+				const raw = _serverImpl.getCookieJar().get(name);
+				return codec.parse(raw);
+			}
+			assertNotHttpOnlyClient("get");
+			if (_clientImpl) {
+				const raw = _clientImpl.getCookieValue(name);
+				return codec.parse(raw);
+			}
+			throw new Error(`[timber] defineCookie('${name}').get() — no environment registered. Ensure @timber-js/app/server or @timber-js/app/client is imported.`);
+		},
+		set(value) {
+			if (_serverImpl) {
+				const jar = _serverImpl.getCookieJar();
+				const serialized = codec.serialize(value);
+				if (serialized === null) jar.delete(name, {
+					path: resolvedOptions.path,
+					domain: resolvedOptions.domain
+				});
+				else jar.set(name, serialized, resolvedOptions);
+				return;
+			}
+			assertNotHttpOnlyClient("set");
+			if (_clientImpl) {
+				const serialized = codec.serialize(value);
+				if (serialized === null) _clientImpl.deleteCookieValue(name, getClientOpts());
+				else _clientImpl.setCookieValue(name, serialized, getClientOpts());
+				return;
+			}
+			throw new Error(`[timber] defineCookie('${name}').set() — no environment registered. Ensure @timber-js/app/server or @timber-js/app/client is imported.`);
+		},
+		delete() {
+			if (_serverImpl) {
+				_serverImpl.getCookieJar().delete(name, {
+					path: resolvedOptions.path,
+					domain: resolvedOptions.domain
+				});
+				return;
+			}
+			assertNotHttpOnlyClient("delete");
+			if (_clientImpl) {
+				_clientImpl.deleteCookieValue(name, getClientOpts());
+				return;
+			}
+			throw new Error(`[timber] defineCookie('${name}').delete() — no environment registered. Ensure @timber-js/app/server or @timber-js/app/client is imported.`);
+		}
+	};
+	if (isHttpOnly) return base;
+	return {
+		...base,
+		useCookie() {
+			const { useCookie: useRawCookie } = getUseCookieModule();
+			const [raw, setRaw, deleteRaw] = useRawCookie(name, getClientOpts());
+			const parsed = codec.parse(raw);
+			const setTyped = (value) => {
+				const serialized = codec.serialize(value);
+				if (serialized === null) deleteRaw();
+				else setRaw(serialized);
+			};
+			return [
+				parsed,
+				setTyped,
+				deleteRaw
+			];
+		}
+	};
+}
+//#endregion
+export { defineCookie as i, _registerServerCookieImpl as n, _registerUseCookieModule as r, _registerFromSchema as t };
+
+//# sourceMappingURL=define-cookie-BjpIt4UC.js.map

package/dist/_chunks/define-cookie-BjpIt4UC.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"define-cookie-BjpIt4UC.js","names":[],"sources":["../../src/cookies/define-cookie.ts"],"sourcesContent":["/**\n * defineCookie — typed cookie definitions.\n *\n * Bundles name + codec + options into a reusable CookieDefinition<T>\n * with sync .get(), .set(), .delete() isomorphic methods (server + client)\n * and a .useCookie() client hook.\n *\n * Uses the registration pattern: server entry registers serverCookieImpl,\n * client entry registers clientCookieImpl. This avoids top-level value\n * imports from either environment and makes defineCookie isomorphic\n * without `typeof window` checks.\n *\n * Standard Schema objects (Zod, Valibot, ArkType) are auto-detected in\n * the codec option — no explicit fromSchema() wrapper needed.\n *\n * See design/29-cookies.md §\"Typed Cookies with Schema Validation\"\n */\n\nimport type { CookieOptions } from '../server/cookie-context.js';\nimport type { ClientCookieOptions } from '../client/use-cookie.js';\n\n// ─── Types ────────────────────────────────────────────────────────────────\n\nimport type { Codec } from '../codec.js';\nimport type { StandardSchemaV1 } from '../schema-bridge.js';\n\n/**\n * A codec that converts between string cookie values and typed values.\n * Type alias for the shared Codec<T> protocol.\n */\nexport type CookieCodec<T> = Codec<T>;\n\n/** Options for defineCookie: codec + CookieOptions merged. */\nexport interface DefineCookieOptions<T, HttpOnly extends boolean = boolean> extends CookieOptions {\n  /**\n   * Codec for parsing/serializing the cookie value.\n   * Accepts a Codec<T> or a Standard Schema object (Zod, Valibot, ArkType)\n   * which is auto-wrapped via fromSchema.\n   */\n  codec: CookieCodec<T> | StandardSchemaV1<T>;\n  /**\n   * Prevent client-side JS access. Default: true.\n   * When true (or omitted), client methods (useCookie, get/set/delete on\n   * client) are omitted from the return type and throw at runtime.\n   */\n  httpOnly?: HttpOnly;\n}\n\n/**\n * Server-only cookie definition. Returned when httpOnly is true or omitted.\n * Client methods are absent from the type — accessing them is a TS error.\n */\nexport interface ServerOnlyCookieDefinition<T> {\n  readonly name: string;\n  readonly options: CookieOptions;\n  readonly codec: CookieCodec<T>;\n\n  /** Read the typed value. Sync, isomorphic (server + client). */\n  get(): T;\n  /** Set the typed value. Sync, isomorphic (server + client). */\n  set(value: T): void;\n  /** Delete the cookie. Sync, isomorphic (server + client). */\n  delete(): void;\n}\n\n/**\n * Full cookie definition with client methods. Returned when httpOnly: false.\n */\nexport interface CookieDefinition<T> extends ServerOnlyCookieDefinition<T> {\n  /** Client: React hook for reading/writing this cookie. Returns [value, setter, deleter]. */\n  useCookie(): [T, (value: T) => void, () => void];\n}\n\n// ─── Registration Pattern ─────────────────────────────────────────────────\n//\n// Server and client entries register their implementations at module load\n// time. This avoids dynamic imports (which lose ALS context) and typeof\n// window checks (which are fragile).\n\n/** Server-side cookie impl: reads from ALS-backed cookie jar. */\nexport interface ServerCookieImpl {\n  getCookieJar(): {\n    get(name: string): string | undefined;\n    set(name: string, value: string, options?: CookieOptions): void;\n    delete(name: string, options?: Pick<CookieOptions, 'path' | 'domain'>): void;\n  };\n}\n\n/** Client-side cookie impl: reads/writes document.cookie via useCookie hook. */\nexport interface ClientCookieImpl {\n  useCookie(\n    name: string,\n    options?: ClientCookieOptions\n  ): [string | undefined, (value: string, options?: ClientCookieOptions) => void, () => void];\n  getCookieValue(name: string): string | undefined;\n  setCookieValue(name: string, value: string, options?: ClientCookieOptions): void;\n  deleteCookieValue(name: string, options?: ClientCookieOptions): void;\n}\n\nlet _serverImpl: ServerCookieImpl | undefined;\nlet _clientImpl: ClientCookieImpl | undefined;\nlet _fromSchemaFn: ((schema: StandardSchemaV1<unknown>) => CookieCodec<unknown>) | undefined;\n\n/**\n * Register the server-side cookie implementation.\n * Called by server entry at module load time.\n * @internal\n */\nexport function _registerServerCookieImpl(impl: ServerCookieImpl): void {\n  _serverImpl = impl;\n}\n\n/**\n * Register the client-side cookie implementation.\n * Called by client entry at module load time.\n * @internal\n */\nexport function _registerClientCookieImpl(impl: ClientCookieImpl): void {\n  _clientImpl = impl;\n}\n\n/**\n * Register the fromSchema bridge function.\n * Called by server/client entry at module load time.\n * @internal\n */\nexport function _registerFromSchema(\n  fn: (schema: StandardSchemaV1<unknown>) => CookieCodec<unknown>\n): void {\n  _fromSchemaFn = fn;\n}\n\n// Legacy registration for useCookie module — still used by client/index.ts\nlet _useCookieModule: typeof import('../client/use-cookie.js') | undefined;\n\nfunction getUseCookieModule(): typeof import('../client/use-cookie.js') {\n  if (!_useCookieModule) {\n    throw new Error(\n      '[timber] defineCookie().useCookie() requires @timber-js/app/client to be loaded. ' +\n        'This hook can only be used in client components.'\n    );\n  }\n  return _useCookieModule;\n}\n\n/**\n * Register the client cookie module. Called by the client entry to wire\n * up the lazy reference without a top-level import.\n *\n * @internal — framework use only\n */\nexport function _registerUseCookieModule(mod: typeof import('../client/use-cookie.js')): void {\n  _useCookieModule = mod;\n  // Also register the client impl from the module\n  _clientImpl = {\n    useCookie: mod.useCookie,\n    getCookieValue: (name: string) => {\n      if (typeof document === 'undefined') return undefined;\n      const match = document.cookie.match(\n        new RegExp('(?:^|;\\\\s*)' + name.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&') + '\\\\s*=\\\\s*([^;]*)')\n      );\n      return match ? decodeURIComponent(match[1]) : undefined;\n    },\n    setCookieValue: (name: string, value: string, options?: ClientCookieOptions) => {\n      const parts: string[] = [`${name}=${encodeURIComponent(value)}`];\n      const path = options?.path ?? '/';\n      parts.push(`Path=${path}`);\n      if (options?.domain) parts.push(`Domain=${options.domain}`);\n      if (options?.maxAge !== undefined) parts.push(`Max-Age=${options.maxAge}`);\n      if (options?.expires) parts.push(`Expires=${options.expires.toUTCString()}`);\n      const sameSite = options?.sameSite ?? 'lax';\n      parts.push(`SameSite=${sameSite.charAt(0).toUpperCase()}${sameSite.slice(1)}`);\n      if (options?.secure) parts.push('Secure');\n      document.cookie = parts.join('; ');\n      // Notify useCookie subscribers so mounted hooks re-render\n      mod.notifyCookieChange(name);\n    },\n    deleteCookieValue: (name: string, options?: ClientCookieOptions) => {\n      const path = options?.path ?? '/';\n      const domain = options?.domain;\n      let cookieStr = `${name}=; Max-Age=0; Expires=Thu, 01 Jan 1970 00:00:00 GMT; Path=${path}`;\n      if (domain) cookieStr += `; Domain=${domain}`;\n      document.cookie = cookieStr;\n      mod.notifyCookieChange(name);\n    },\n  };\n}\n\n// ─── Standard Schema Auto-Detection ───────────────────────────────────────\n\nfunction resolveCodec<T>(codecOrSchema: CookieCodec<T> | StandardSchemaV1<T>): CookieCodec<T> {\n  // If it has parse + serialize, it's already a Codec\n  if (\n    typeof (codecOrSchema as Codec<T>).parse === 'function' &&\n    typeof (codecOrSchema as Codec<T>).serialize === 'function'\n  ) {\n    return codecOrSchema as CookieCodec<T>;\n  }\n\n  // Auto-detect Standard Schema\n  if (typeof codecOrSchema === 'object' && codecOrSchema !== null && '~standard' in codecOrSchema) {\n    if (!_fromSchemaFn) {\n      throw new Error(\n        '[timber] defineCookie: Standard Schema auto-detection requires @timber-js/app/server or ' +\n          '@timber-js/app/client to be loaded. Pass an explicit Codec<T> with parse/serialize methods, ' +\n          'or ensure the framework entry module is imported.'\n      );\n    }\n    return _fromSchemaFn(codecOrSchema as StandardSchemaV1<unknown>) as CookieCodec<T>;\n  }\n\n  throw new Error(\n    '[timber] defineCookie: codec must be a Codec<T> (with parse/serialize methods) ' +\n      'or a Standard Schema object (Zod, Valibot, ArkType).'\n  );\n}\n\n// ─── Factory ──────────────────────────────────────────────────────────────\n\n/**\n * Define a typed cookie.\n *\n * ```ts\n * import { defineCookie } from '@timber-js/app/cookies';\n * import { z } from 'zod/v4';\n *\n * // httpOnly: false — client methods available\n * export const themeCookie = defineCookie('theme', {\n *   codec: z.enum(['light', 'dark', 'system']).default('system'),\n *   httpOnly: false,\n *   maxAge: 60 * 60 * 24 * 365,\n * });\n *\n * // Server or client\n * const theme = themeCookie.get();\n * themeCookie.set('dark');\n *\n * // Client hook\n * const [theme, setTheme] = themeCookie.useCookie();\n *\n * // httpOnly: true (default) — server-only, no client methods\n * export const sessionCookie = defineCookie('session', {\n *   codec: z.string(),\n * });\n * sessionCookie.get();       // works on server\n * sessionCookie.useCookie(); // TS error — httpOnly cookie\n * ```\n */\nexport function defineCookie<T, HttpOnly extends boolean = true>(\n  name: string,\n  options: DefineCookieOptions<T, HttpOnly>\n): HttpOnly extends false ? CookieDefinition<T> : ServerOnlyCookieDefinition<T> {\n  const { codec: codecOrSchema, ...cookieOpts } = options;\n  const codec = resolveCodec(codecOrSchema);\n  const resolvedOptions: CookieOptions = { ...cookieOpts };\n  const isHttpOnly = options.httpOnly !== false; // default true\n\n  function getClientOpts(): ClientCookieOptions {\n    return {\n      path: resolvedOptions.path,\n      domain: resolvedOptions.domain,\n      maxAge: resolvedOptions.maxAge,\n      expires: resolvedOptions.expires,\n      sameSite: resolvedOptions.sameSite,\n      secure: resolvedOptions.secure,\n    };\n  }\n\n  function assertNotHttpOnlyClient(method: string): void {\n    if (isHttpOnly && !_serverImpl) {\n      throw new Error(\n        `[timber] defineCookie('${name}').${method}() cannot be used with httpOnly cookies — ` +\n          `the browser cannot access them. Set httpOnly: false to enable client access.`\n      );\n    }\n  }\n\n  const base: ServerOnlyCookieDefinition<T> = {\n    name,\n    options: resolvedOptions,\n    codec,\n\n    get(): T {\n      if (_serverImpl) {\n        const jar = _serverImpl.getCookieJar();\n        const raw = jar.get(name);\n        return codec.parse(raw);\n      }\n      // Client path\n      assertNotHttpOnlyClient('get');\n      if (_clientImpl) {\n        const raw = _clientImpl.getCookieValue(name);\n        return codec.parse(raw);\n      }\n      throw new Error(\n        `[timber] defineCookie('${name}').get() — no environment registered. ` +\n          'Ensure @timber-js/app/server or @timber-js/app/client is imported.'\n      );\n    },\n\n    set(value: T): void {\n      if (_serverImpl) {\n        const jar = _serverImpl.getCookieJar();\n        const serialized = codec.serialize(value);\n        if (serialized === null) {\n          jar.delete(name, {\n            path: resolvedOptions.path,\n            domain: resolvedOptions.domain,\n          });\n        } else {\n          jar.set(name, serialized, resolvedOptions);\n        }\n        return;\n      }\n      // Client path\n      assertNotHttpOnlyClient('set');\n      if (_clientImpl) {\n        const serialized = codec.serialize(value);\n        if (serialized === null) {\n          _clientImpl.deleteCookieValue(name, getClientOpts());\n        } else {\n          _clientImpl.setCookieValue(name, serialized, getClientOpts());\n        }\n        return;\n      }\n      throw new Error(\n        `[timber] defineCookie('${name}').set() — no environment registered. ` +\n          'Ensure @timber-js/app/server or @timber-js/app/client is imported.'\n      );\n    },\n\n    delete(): void {\n      if (_serverImpl) {\n        const jar = _serverImpl.getCookieJar();\n        jar.delete(name, {\n          path: resolvedOptions.path,\n          domain: resolvedOptions.domain,\n        });\n        return;\n      }\n      // Client path\n      assertNotHttpOnlyClient('delete');\n      if (_clientImpl) {\n        _clientImpl.deleteCookieValue(name, getClientOpts());\n        return;\n      }\n      throw new Error(\n        `[timber] defineCookie('${name}').delete() — no environment registered. ` +\n          'Ensure @timber-js/app/server or @timber-js/app/client is imported.'\n      );\n    },\n  };\n\n  if (isHttpOnly) {\n    return base as HttpOnly extends false ? CookieDefinition<T> : ServerOnlyCookieDefinition<T>;\n  }\n\n  // httpOnly: false — add useCookie client hook\n  const full: CookieDefinition<T> = {\n    ...base,\n\n    useCookie(): [T, (value: T) => void, () => void] {\n      const { useCookie: useRawCookie } = getUseCookieModule();\n\n      const clientOpts = getClientOpts();\n      const [raw, setRaw, deleteRaw] = useRawCookie(name, clientOpts);\n      const parsed = codec.parse(raw);\n\n      const setTyped = (value: T): void => {\n        const serialized = codec.serialize(value);\n        if (serialized === null) {\n          deleteRaw();\n        } else {\n          setRaw(serialized);\n        }\n      };\n\n      return [parsed, setTyped, deleteRaw];\n    },\n  };\n\n  return full as HttpOnly extends false ? CookieDefinition<T> : ServerOnlyCookieDefinition<T>;\n}\n"],"mappings":"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"}

package/dist/_chunks/format-Bcn-Iv1x.js

@@ -0,0 +1,14 @@
+//#region src/utils/format.ts
+/**
+* Shared formatting utilities.
+*/
+/** Format a byte count as a human-readable string (e.g. "1.50 kB"). */
+function formatSize(bytes) {
+	if (bytes < 1024) return `${bytes} B`;
+	if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(2)} kB`;
+	return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
+}
+//#endregion
+export { formatSize as t };
+
+//# sourceMappingURL=format-Bcn-Iv1x.js.map

package/dist/_chunks/format-Bcn-Iv1x.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"format-Bcn-Iv1x.js","names":[],"sources":["../../src/utils/format.ts"],"sourcesContent":["/**\n * Shared formatting utilities.\n */\n\n/** Format a byte count as a human-readable string (e.g. \"1.50 kB\"). */\nexport function formatSize(bytes: number): string {\n  if (bytes < 1024) return `${bytes} B`;\n  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(2)} kB`;\n  return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;\n}\n"],"mappings":";;;;;AAKA,SAAgB,WAAW,OAAuB;AAChD,KAAI,QAAQ,KAAM,QAAO,GAAG,MAAM;AAClC,KAAI,QAAQ,OAAO,KAAM,QAAO,IAAI,QAAQ,MAAM,QAAQ,EAAE,CAAC;AAC7D,QAAO,IAAI,SAAS,OAAO,OAAO,QAAQ,EAAE,CAAC"}

package/dist/_chunks/handler-store-B-lqaGyh.js

@@ -0,0 +1,54 @@
+//#region src/cache/handler-store.ts
+var handler = null;
+/** Replace the active cache handler. Called by the framework at boot. */
+function setCacheHandler(h) {
+	handler = h;
+}
+/**
+* Get the active cache handler. Creates a default MemoryCacheHandler on
+* first access if none has been set via setCacheHandler().
+*/
+function getCacheHandler() {
+	if (!handler) handler = createDefaultHandler();
+	return handler;
+}
+function createDefaultHandler() {
+	const store = /* @__PURE__ */ new Map();
+	const maxEntries = 1e3;
+	return {
+		async get(key) {
+			const entry = store.get(key);
+			if (!entry) return null;
+			store.delete(key);
+			store.set(key, entry);
+			const stale = Date.now() > entry.expiresAt;
+			return {
+				value: entry.value,
+				stale
+			};
+		},
+		async set(key, value, opts) {
+			if (store.has(key)) store.delete(key);
+			while (store.size >= maxEntries) {
+				const oldest = store.keys().next().value;
+				if (oldest !== void 0) store.delete(oldest);
+				else break;
+			}
+			store.set(key, {
+				value,
+				expiresAt: Date.now() + opts.ttl * 1e3,
+				tags: opts.tags
+			});
+		},
+		async invalidate(opts) {
+			if (opts.key) store.delete(opts.key);
+			if (opts.tag) {
+				for (const [key, entry] of store) if (entry.tags.includes(opts.tag)) store.delete(key);
+			}
+		}
+	};
+}
+//#endregion
+export { setCacheHandler as n, getCacheHandler as t };
+
+//# sourceMappingURL=handler-store-B-lqaGyh.js.map

package/dist/_chunks/handler-store-B-lqaGyh.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handler-store-B-lqaGyh.js","names":[],"sources":["../../src/cache/handler-store.ts"],"sourcesContent":["/**\n * Module-level cache handler singleton.\n *\n * Lazily initialized to MemoryCacheHandler on first access. The framework\n * replaces this at boot from timber.config.ts via setCacheHandler().\n *\n * This module avoids importing from ./index to prevent circular dependencies.\n */\n\n// Inline the interface to avoid circular import with index.ts\ninterface CacheHandlerLike {\n  get(key: string): Promise<{ value: unknown; stale: boolean } | null>;\n  set(key: string, value: unknown, opts: { ttl: number; tags: string[] }): Promise<void>;\n  invalidate(opts: { key?: string; tag?: string }): Promise<void>;\n}\n\nlet handler: CacheHandlerLike | null = null;\n\n/** Replace the active cache handler. Called by the framework at boot. */\nexport function setCacheHandler(h: CacheHandlerLike): void {\n  handler = h;\n}\n\n/**\n * Get the active cache handler. Creates a default MemoryCacheHandler on\n * first access if none has been set via setCacheHandler().\n */\nexport function getCacheHandler(): CacheHandlerLike {\n  if (!handler) {\n    // Inline a minimal LRU cache to avoid circular dep with index.ts.\n    // In production, the framework always calls setCacheHandler() at boot.\n    handler = createDefaultHandler();\n  }\n  return handler;\n}\n\nfunction createDefaultHandler(): CacheHandlerLike {\n  const store = new Map<string, { value: unknown; expiresAt: number; tags: string[] }>();\n  const maxEntries = 1000;\n\n  return {\n    async get(key) {\n      const entry = store.get(key);\n      if (!entry) return null;\n      store.delete(key);\n      store.set(key, entry);\n      const stale = Date.now() > entry.expiresAt;\n      return { value: entry.value, stale };\n    },\n    async set(key, value, opts) {\n      if (store.has(key)) store.delete(key);\n      while (store.size >= maxEntries) {\n        const oldest = store.keys().next().value;\n        if (oldest !== undefined) store.delete(oldest);\n        else break;\n      }\n      store.set(key, { value, expiresAt: Date.now() + opts.ttl * 1000, tags: opts.tags });\n    },\n    async invalidate(opts) {\n      if (opts.key) store.delete(opts.key);\n      if (opts.tag) {\n        for (const [key, entry] of store) {\n          if (entry.tags.includes(opts.tag)) store.delete(key);\n        }\n      }\n    },\n  };\n}\n"],"mappings":";AAgBA,IAAI,UAAmC;;AAGvC,SAAgB,gBAAgB,GAA2B;AACzD,WAAU;;;;;;AAOZ,SAAgB,kBAAoC;AAClD,KAAI,CAAC,QAGH,WAAU,sBAAsB;AAElC,QAAO;;AAGT,SAAS,uBAAyC;CAChD,MAAM,wBAAQ,IAAI,KAAoE;CACtF,MAAM,aAAa;AAEnB,QAAO;EACL,MAAM,IAAI,KAAK;GACb,MAAM,QAAQ,MAAM,IAAI,IAAI;AAC5B,OAAI,CAAC,MAAO,QAAO;AACnB,SAAM,OAAO,IAAI;AACjB,SAAM,IAAI,KAAK,MAAM;GACrB,MAAM,QAAQ,KAAK,KAAK,GAAG,MAAM;AACjC,UAAO;IAAE,OAAO,MAAM;IAAO;IAAO;;EAEtC,MAAM,IAAI,KAAK,OAAO,MAAM;AAC1B,OAAI,MAAM,IAAI,IAAI,CAAE,OAAM,OAAO,IAAI;AACrC,UAAO,MAAM,QAAQ,YAAY;IAC/B,MAAM,SAAS,MAAM,MAAM,CAAC,MAAM,CAAC;AACnC,QAAI,WAAW,KAAA,EAAW,OAAM,OAAO,OAAO;QACzC;;AAEP,SAAM,IAAI,KAAK;IAAE;IAAO,WAAW,KAAK,KAAK,GAAG,KAAK,MAAM;IAAM,MAAM,KAAK;IAAM,CAAC;;EAErF,MAAM,WAAW,MAAM;AACrB,OAAI,KAAK,IAAK,OAAM,OAAO,KAAK,IAAI;AACpC,OAAI,KAAK;SACF,MAAM,CAAC,KAAK,UAAU,MACzB,KAAI,MAAM,KAAK,SAAS,KAAK,IAAI,CAAE,OAAM,OAAO,IAAI;;;EAI3D"}