@velajs/cloudflare 1.29.0 → 1.30.0

package/dist/rate-limit/cloudflare-rate-limit.store.js

@@ -0,0 +1,40 @@
+//#region src/rate-limit/cloudflare-rate-limit.store.ts
+/**
+* Adapt a Cloudflare Workers Rate Limiting binding to Vela's throttler store.
+*
+* The platform binding makes the allow/deny decision. It does not expose exact
+* counters or reset timestamps, so this adapter intentionally omits `remaining`.
+*/
+function cloudflareRateLimitStore(binding, options) {
+	if (!binding || typeof binding !== "function" && typeof binding.limit !== "function") throw new TypeError("A Cloudflare Rate Limiting binding is required");
+	if (!Number.isSafeInteger(options.limit) || options.limit <= 0 || options.limit >= Number.MAX_SAFE_INTEGER) throw new RangeError("Rate limit must be a positive safe integer");
+	if (options.periodSeconds !== 10 && options.periodSeconds !== 60) throw new RangeError("Cloudflare rate-limit periods must be 10 or 60 seconds");
+	const maxKeyBytes = options.maxKeyBytes ?? 1024;
+	if (!Number.isSafeInteger(maxKeyBytes) || maxKeyBytes <= 0 || maxKeyBytes > 4096) throw new RangeError("maxKeyBytes must be between 1 and 4096");
+	const ttlMs = options.periodSeconds * 1e3;
+	const encoder = new TextEncoder();
+	const resolveBinding = typeof binding === "function" ? binding : () => binding;
+	return {
+		async increment(key, requestedTtlMs) {
+			if (requestedTtlMs !== ttlMs) throw new Error(`Cloudflare binding period mismatch: expected ${ttlMs}ms, received ${requestedTtlMs}ms`);
+			if (typeof key !== "string" || key.length === 0 || /[\u0000-\u001f\u007f]/.test(key) || encoder.encode(key).byteLength > maxKeyBytes) throw new Error("Refusing an invalid or oversized rate-limit key");
+			const currentBinding = resolveBinding();
+			if (!currentBinding || typeof currentBinding.limit !== "function") throw new Error("Cloudflare Rate Limiting binding is unavailable");
+			const decision = await currentBinding.limit({ key });
+			if (!decision || typeof decision.success !== "boolean") throw new Error("Cloudflare rate-limit binding returned an invalid decision");
+			return {
+				count: decision.success ? 0 : options.limit + 1,
+				ttlMs,
+				allowed: decision.success,
+				enforcedLimit: options.limit
+			};
+		},
+		reset() {
+			throw new Error("Cloudflare Rate Limiting bindings do not support counter reset");
+		}
+	};
+}
+//#endregion
+export { cloudflareRateLimitStore };
+
+//# sourceMappingURL=cloudflare-rate-limit.store.js.map

package/dist/rate-limit/cloudflare-rate-limit.store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloudflare-rate-limit.store.js","names":[],"sources":["../../src/rate-limit/cloudflare-rate-limit.store.ts"],"sourcesContent":["import type { ThrottlerStorageRecord, ThrottlerStore } from '@velajs/vela/throttler';\n\n/** The deliberately small surface exposed by a Workers Rate Limiting binding. */\nexport interface CloudflareRateLimitBinding {\n  limit(input: { key: string }): Promise<{ success: boolean }>;\n}\n\nexport interface CloudflareRateLimitStoreOptions {\n  /** Must match the binding's configured `simple.limit`. */\n  limit: number;\n  /** Must match the binding's configured `simple.period`. */\n  periodSeconds: 10 | 60;\n  /** Bound attacker-influenced tracking keys before calling the platform. */\n  maxKeyBytes?: number;\n}\n\n/**\n * Adapt a Cloudflare Workers Rate Limiting binding to Vela's throttler store.\n *\n * The platform binding makes the allow/deny decision. It does not expose exact\n * counters or reset timestamps, so this adapter intentionally omits `remaining`.\n */\nexport function cloudflareRateLimitStore(\n  binding: CloudflareRateLimitBinding | (() => CloudflareRateLimitBinding),\n  options: CloudflareRateLimitStoreOptions,\n): ThrottlerStore {\n  if (!binding || (typeof binding !== 'function' && typeof binding.limit !== 'function')) {\n    throw new TypeError('A Cloudflare Rate Limiting binding is required');\n  }\n  if (\n    !Number.isSafeInteger(options.limit) ||\n    options.limit <= 0 ||\n    options.limit >= Number.MAX_SAFE_INTEGER\n  ) {\n    throw new RangeError('Rate limit must be a positive safe integer');\n  }\n  if (options.periodSeconds !== 10 && options.periodSeconds !== 60) {\n    throw new RangeError('Cloudflare rate-limit periods must be 10 or 60 seconds');\n  }\n\n  const maxKeyBytes = options.maxKeyBytes ?? 1_024;\n  if (!Number.isSafeInteger(maxKeyBytes) || maxKeyBytes <= 0 || maxKeyBytes > 4_096) {\n    throw new RangeError('maxKeyBytes must be between 1 and 4096');\n  }\n\n  const ttlMs = options.periodSeconds * 1_000;\n  const encoder = new TextEncoder();\n  const resolveBinding =\n    typeof binding === 'function' ? binding : (): CloudflareRateLimitBinding => binding;\n\n  return {\n    async increment(key: string, requestedTtlMs: number): Promise<ThrottlerStorageRecord> {\n      if (requestedTtlMs !== ttlMs) {\n        throw new Error(\n          `Cloudflare binding period mismatch: expected ${ttlMs}ms, received ${requestedTtlMs}ms`,\n        );\n      }\n      if (\n        typeof key !== 'string' ||\n        key.length === 0 ||\n        /[\\u0000-\\u001f\\u007f]/.test(key) ||\n        encoder.encode(key).byteLength > maxKeyBytes\n      ) {\n        throw new Error('Refusing an invalid or oversized rate-limit key');\n      }\n\n      const currentBinding = resolveBinding();\n      if (!currentBinding || typeof currentBinding.limit !== 'function') {\n        throw new Error('Cloudflare Rate Limiting binding is unavailable');\n      }\n      const decision = await currentBinding.limit({ key });\n      if (!decision || typeof decision.success !== 'boolean') {\n        throw new Error('Cloudflare rate-limit binding returned an invalid decision');\n      }\n\n      return {\n        // Vela consumes `allowed` as the authoritative platform decision. These\n        // sentinel counts preserve compatibility without inventing a counter.\n        count: decision.success ? 0 : options.limit + 1,\n        ttlMs,\n        allowed: decision.success,\n        enforcedLimit: options.limit,\n      };\n    },\n\n    reset(): never {\n      throw new Error('Cloudflare Rate Limiting bindings do not support counter reset');\n    },\n  };\n}\n"],"mappings":";;;;;;;AAsBA,SAAgB,yBACd,SACA,SACgB;CAChB,IAAI,CAAC,WAAY,OAAO,YAAY,cAAc,OAAO,QAAQ,UAAU,YACzE,MAAM,IAAI,UAAU,gDAAgD;CAEtE,IACE,CAAC,OAAO,cAAc,QAAQ,KAAK,KACnC,QAAQ,SAAS,KACjB,QAAQ,SAAS,OAAO,kBAExB,MAAM,IAAI,WAAW,4CAA4C;CAEnE,IAAI,QAAQ,kBAAkB,MAAM,QAAQ,kBAAkB,IAC5D,MAAM,IAAI,WAAW,wDAAwD;CAG/E,MAAM,cAAc,QAAQ,eAAe;CAC3C,IAAI,CAAC,OAAO,cAAc,WAAW,KAAK,eAAe,KAAK,cAAc,MAC1E,MAAM,IAAI,WAAW,wCAAwC;CAG/D,MAAM,QAAQ,QAAQ,gBAAgB;CACtC,MAAM,UAAU,IAAI,YAAY;CAChC,MAAM,iBACJ,OAAO,YAAY,aAAa,gBAA4C;CAE9E,OAAO;EACL,MAAM,UAAU,KAAa,gBAAyD;GACpF,IAAI,mBAAmB,OACrB,MAAM,IAAI,MACR,gDAAgD,MAAM,eAAe,eAAe,GACtF;GAEF,IACE,OAAO,QAAQ,YACf,IAAI,WAAW,KACf,wBAAwB,KAAK,GAAG,KAChC,QAAQ,OAAO,GAAG,CAAC,CAAC,aAAa,aAEjC,MAAM,IAAI,MAAM,iDAAiD;GAGnE,MAAM,iBAAiB,eAAe;GACtC,IAAI,CAAC,kBAAkB,OAAO,eAAe,UAAU,YACrD,MAAM,IAAI,MAAM,iDAAiD;GAEnE,MAAM,WAAW,MAAM,eAAe,MAAM,EAAE,IAAI,CAAC;GACnD,IAAI,CAAC,YAAY,OAAO,SAAS,YAAY,WAC3C,MAAM,IAAI,MAAM,4DAA4D;GAG9E,OAAO;IAGL,OAAO,SAAS,UAAU,IAAI,QAAQ,QAAQ;IAC9C;IACA,SAAS,SAAS;IAClB,eAAe,QAAQ;GACzB;EACF;EAEA,QAAe;GACb,MAAM,IAAI,MAAM,gEAAgE;EAClF;CACF;AACF"}

package/dist/schedule-diagnostics.js

@@ -0,0 +1,51 @@
+import { cronDialectAmbiguity, parseCronMetadata, parseIntervalMetadata, scheduledJobComponents } from "@velajs/vela/module-kit";
+//#region src/schedule-diagnostics.ts
+const reported = /* @__PURE__ */ new Set();
+/** `'throw'` fails the caller, `'log'` warns once per message in this isolate. */
+function reportScheduleDiagnostic(container, message) {
+	const mode = container.getDiagnostics();
+	if (mode === "silent") return;
+	if (mode === "throw") throw new Error(message);
+	if (reported.has(message)) return;
+	reported.add(message);
+	console.warn(message);
+}
+function jobName(entry) {
+	return `${typeof entry.token === "function" ? entry.token.name : String(entry.token)}.${entry.meta.methodName}`;
+}
+/**
+* Guards, interceptors and filters declared for a job never run on its
+* trigger, and a direct job that declares guards is refused on every trigger.
+*/
+function reportComponents(container, label, entry) {
+	const decorators = scheduledJobComponents(container, entry);
+	if (decorators.length === 0) return;
+	reportScheduleDiagnostic(container, `[vela] ${label} declares ${decorators.length > 1 ? `${decorators.slice(0, -1).join(", ")} and ${decorators.at(-1)}` : decorators.join("")}, which do not run for scheduled jobs: a direct job runs no guards, interceptors or filters${decorators.includes("@UseGuards") ? ", and one that declares guards refuses to run" : ""}. Use signed ScheduleModule dispatch and declare them on the signed route to run the job through the request pipeline.`);
+}
+/**
+* Report schedule declarations a Workers cron trigger cannot honor as written:
+* a dialect-ambiguous `@Cron`, `dialect: 'unix'`, `timeZone: 'local'`,
+* `@Interval` jobs, and guards, interceptors or filters declared for a job
+* (a direct job that declares guards is refused when it fires).
+* The container's diagnostics policy applies: `'throw'` fails bootstrap and the
+* default `'log'` warns once per declaration, so the first event of a Worker
+* (which bootstraps the application) never fails because of these checks.
+* `vela deploy check` rejects the cron declarations, `@Interval` jobs and
+* guarded direct jobs before deployment (`ambiguous-cron-dialect`,
+* `incompatible-cron-options`, `unsupported-interval`, `scheduled-job-guards`).
+*/
+function reportCloudflareScheduleDiagnostics(container, entrypoints) {
+	for (const entry of entrypoints.ofKind("schedule:cron", parseCronMetadata)) {
+		const cron = `@Cron('${entry.meta.expression}') on ${jobName(entry)}`;
+		const ambiguity = cronDialectAmbiguity(entry.meta);
+		if (ambiguity) reportScheduleDiagnostic(container, `[vela] ${cron} declares no dialect, and ${ambiguity}. Workers deliver the trigger with Cloudflare semantics while Node reads it with Vela's unix dialect; declare { dialect: 'cloudflare' } so it fires on the same days on every runtime.`);
+		if (entry.meta.dialect === "unix") reportScheduleDiagnostic(container, `[vela] ${cron} declares dialect 'unix', but Cloudflare delivers its trigger with Cloudflare cron semantics (weekdays 1 = Sunday through 7 = Saturday). Declare { dialect: 'cloudflare' } and write the expression for Cloudflare.`);
+		if (entry.meta.timeZone === "local") reportScheduleDiagnostic(container, `[vela] ${cron} declares timeZone 'local', but Cloudflare cron triggers run in UTC. Remove timeZone or set it to 'UTC'.`);
+		reportComponents(container, cron, entry);
+	}
+	for (const entry of entrypoints.ofKind("schedule:interval", parseIntervalMetadata)) reportScheduleDiagnostic(container, `[vela] @Interval(${entry.meta.ms}) on ${jobName(entry)} never runs on Workers: cron triggers drive only @Cron jobs. Replace it with a @Cron job and a Wrangler trigger, or run it under ScheduleNodeModule on Node.`);
+}
+//#endregion
+export { reportCloudflareScheduleDiagnostics };
+
+//# sourceMappingURL=schedule-diagnostics.js.map

package/dist/schedule-diagnostics.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schedule-diagnostics.js","names":[],"sources":["../src/schedule-diagnostics.ts"],"sourcesContent":["import {\n  cronDialectAmbiguity,\n  parseCronMetadata,\n  parseIntervalMetadata,\n  scheduledJobComponents,\n} from '@velajs/vela/module-kit';\nimport type { VelaApplication } from '@velajs/vela';\nimport type { Entrypoint, Container } from '@velajs/vela/module-kit';\n\nconst reported = new Set<string>();\n\n/** `'throw'` fails the caller, `'log'` warns once per message in this isolate. */\nfunction reportScheduleDiagnostic(container: Container, message: string): void {\n  const mode = container.getDiagnostics();\n  if (mode === 'silent') return;\n  if (mode === 'throw') throw new Error(message);\n  if (reported.has(message)) return;\n  reported.add(message);\n  console.warn(message);\n}\n\nfunction jobName(entry: Entrypoint<{ methodName: string }>): string {\n  const owner = typeof entry.token === 'function' ? entry.token.name : String(entry.token);\n  return `${owner}.${entry.meta.methodName}`;\n}\n\n/**\n * Guards, interceptors and filters declared for a job never run on its\n * trigger, and a direct job that declares guards is refused on every trigger.\n */\nfunction reportComponents(\n  container: Container,\n  label: string,\n  entry: Entrypoint<{ methodName: string }>,\n): void {\n  const decorators = scheduledJobComponents(container, entry);\n  if (decorators.length === 0) return;\n  const named =\n    decorators.length > 1\n      ? `${decorators.slice(0, -1).join(', ')} and ${decorators.at(-1)!}`\n      : decorators.join('');\n  const refused = decorators.includes('@UseGuards')\n    ? ', and one that declares guards refuses to run'\n    : '';\n  reportScheduleDiagnostic(\n    container,\n    `[vela] ${label} declares ${named}, which do not run for scheduled jobs: a direct job ` +\n      `runs no guards, interceptors or filters${refused}. Use signed ScheduleModule dispatch ` +\n      `and declare them on the signed route to run the job through the request pipeline.`,\n  );\n}\n\n/**\n * Report schedule declarations a Workers cron trigger cannot honor as written:\n * a dialect-ambiguous `@Cron`, `dialect: 'unix'`, `timeZone: 'local'`,\n * `@Interval` jobs, and guards, interceptors or filters declared for a job\n * (a direct job that declares guards is refused when it fires).\n * The container's diagnostics policy applies: `'throw'` fails bootstrap and the\n * default `'log'` warns once per declaration, so the first event of a Worker\n * (which bootstraps the application) never fails because of these checks.\n * `vela deploy check` rejects the cron declarations, `@Interval` jobs and\n * guarded direct jobs before deployment (`ambiguous-cron-dialect`,\n * `incompatible-cron-options`, `unsupported-interval`, `scheduled-job-guards`).\n */\nexport function reportCloudflareScheduleDiagnostics(\n  container: Container,\n  entrypoints: VelaApplication['entrypoints'],\n): void {\n  for (const entry of entrypoints.ofKind('schedule:cron', parseCronMetadata)) {\n    const cron = `@Cron('${entry.meta.expression}') on ${jobName(entry)}`;\n    const ambiguity = cronDialectAmbiguity(entry.meta);\n    if (ambiguity) {\n      reportScheduleDiagnostic(\n        container,\n        `[vela] ${cron} declares no dialect, and ${ambiguity}. Workers deliver the trigger ` +\n          `with Cloudflare semantics while Node reads it with Vela's unix dialect; declare ` +\n          `{ dialect: 'cloudflare' } so it fires on the same days on every runtime.`,\n      );\n    }\n    if (entry.meta.dialect === 'unix') {\n      reportScheduleDiagnostic(\n        container,\n        `[vela] ${cron} declares dialect 'unix', but Cloudflare delivers its trigger with ` +\n          `Cloudflare cron semantics (weekdays 1 = Sunday through 7 = Saturday). Declare ` +\n          `{ dialect: 'cloudflare' } and write the expression for Cloudflare.`,\n      );\n    }\n    if (entry.meta.timeZone === 'local') {\n      reportScheduleDiagnostic(\n        container,\n        `[vela] ${cron} declares timeZone 'local', but Cloudflare cron triggers run in UTC. ` +\n          `Remove timeZone or set it to 'UTC'.`,\n      );\n    }\n    reportComponents(container, cron, entry);\n  }\n  for (const entry of entrypoints.ofKind('schedule:interval', parseIntervalMetadata)) {\n    reportScheduleDiagnostic(\n      container,\n      `[vela] @Interval(${entry.meta.ms}) on ${jobName(entry)} never runs on Workers: cron ` +\n        `triggers drive only @Cron jobs. Replace it with a @Cron job and a Wrangler trigger, ` +\n        `or run it under ScheduleNodeModule on Node.`,\n    );\n  }\n}\n"],"mappings":";;AASA,MAAM,2BAAW,IAAI,IAAY;;AAGjC,SAAS,yBAAyB,WAAsB,SAAuB;CAC7E,MAAM,OAAO,UAAU,eAAe;CACtC,IAAI,SAAS,UAAU;CACvB,IAAI,SAAS,SAAS,MAAM,IAAI,MAAM,OAAO;CAC7C,IAAI,SAAS,IAAI,OAAO,GAAG;CAC3B,SAAS,IAAI,OAAO;CACpB,QAAQ,KAAK,OAAO;AACtB;AAEA,SAAS,QAAQ,OAAmD;CAElE,OAAO,GADO,OAAO,MAAM,UAAU,aAAa,MAAM,MAAM,OAAO,OAAO,MAAM,KAAK,EACvE,GAAG,MAAM,KAAK;AAChC;;;;;AAMA,SAAS,iBACP,WACA,OACA,OACM;CACN,MAAM,aAAa,uBAAuB,WAAW,KAAK;CAC1D,IAAI,WAAW,WAAW,GAAG;CAQ7B,yBACE,WACA,UAAU,MAAM,YARhB,WAAW,SAAS,IAChB,GAAG,WAAW,MAAM,GAAG,EAAE,CAAC,CAAC,KAAK,IAAI,EAAE,OAAO,WAAW,GAAG,EAAE,MAC7D,WAAW,KAAK,EAAE,EAMY,6FALpB,WAAW,SAAS,YAAY,IAC5C,kDACA,GAIkD,uHAEtD;AACF;;;;;;;;;;;;;AAcA,SAAgB,oCACd,WACA,aACM;CACN,KAAK,MAAM,SAAS,YAAY,OAAO,iBAAiB,iBAAiB,GAAG;EAC1E,MAAM,OAAO,UAAU,MAAM,KAAK,WAAW,QAAQ,QAAQ,KAAK;EAClE,MAAM,YAAY,qBAAqB,MAAM,IAAI;EACjD,IAAI,WACF,yBACE,WACA,UAAU,KAAK,4BAA4B,UAAU,uLAGvD;EAEF,IAAI,MAAM,KAAK,YAAY,QACzB,yBACE,WACA,UAAU,KAAK,oNAGjB;EAEF,IAAI,MAAM,KAAK,aAAa,SAC1B,yBACE,WACA,UAAU,KAAK,yGAEjB;EAEF,iBAAiB,WAAW,MAAM,KAAK;CACzC;CACA,KAAK,MAAM,SAAS,YAAY,OAAO,qBAAqB,qBAAqB,GAC/E,yBACE,WACA,oBAAoB,MAAM,KAAK,GAAG,OAAO,QAAQ,KAAK,EAAE,6JAG1D;AAEJ"}

package/dist/scheduled-event.js

@@ -0,0 +1,68 @@
+import { InjectionToken, Scope, defineProvider } from "@velajs/vela";
+import { SCHEDULE_INVOCATION_SEED } from "@velajs/vela/module-kit";
+//#region src/scheduled-event.ts
+/**
+* Request-scoped Cloudflare view of the scheduled trigger, seeded into each
+* `@Cron` job's invocation scope by the Cloudflare adapter. Inject it where a
+* job needs platform controls such as `noRetry()`; the job's argument stays
+* the portable `ScheduleInvocation`. It resolves only inside a scheduled
+* invocation; resolving it anywhere else throws. A cron job fired on demand
+* (Studio's run-now) receives a synthetic event: `cron` is the job's
+* expression and `noRetry()` does nothing.
+*
+* The token provides itself as request-scoped in every container, so a class
+* that injects it is request-scoped wherever the graph boots (a Worker, a
+* Durable Object, the CLI or a testing module) and is built only for an
+* invocation, never at bootstrap.
+*
+* @example
+* ```ts
+* @Injectable({ scope: Scope.REQUEST })
+* class Reports {
+*   constructor(@Inject(CLOUDFLARE_SCHEDULED_EVENT) private readonly trigger: CloudflareScheduledEvent) {}
+*
+*   @Cron('0 3 * * *', { dialect: 'cloudflare' })
+*   async nightly(tick: CronInvocation) {
+*     if (!(await this.upstreamAvailable(tick.signal))) this.trigger.noRetry();
+*   }
+* }
+* ```
+*/
+const CLOUDFLARE_SCHEDULED_EVENT = new InjectionToken("@velajs/cloudflare:scheduled-event", {
+	scope: Scope.REQUEST,
+	factory: () => {
+		throw new Error("CLOUDFLARE_SCHEDULED_EVENT can only be resolved inside a scheduled invocation: the Cloudflare adapter seeds it into each @Cron job scope for a cron trigger.");
+	}
+});
+/** @internal Freeze the injected view; `noRetry` keeps the native receiver. */
+function cloudflareScheduledEvent(event, scheduledTime) {
+	return Object.freeze({
+		cron: event.cron,
+		scheduledTime,
+		noRetry: () => {
+			event.noRetry?.();
+		}
+	});
+}
+/**
+* Seeds a cron job fired outside a trigger (Studio's run-now) the way a
+* trigger would: a synthetic event whose `cron` is the invocation's
+* expression, with its `scheduledTime` and a `noRetry()` that does nothing.
+* Interval jobs never run from Workers triggers, so they get no event.
+*/
+const seedScheduledEvent = (scope, invocation) => {
+	if (invocation.kind !== "cron") return;
+	scope.setRequestInstance(CLOUDFLARE_SCHEDULED_EVENT, cloudflareScheduledEvent({ cron: invocation.expression }, invocation.scheduledTime));
+};
+/**
+* @internal Provide `SCHEDULE_INVOCATION_SEED`, so jobs fired on demand get a
+* synthetic event. Each trigger seeds the real event into its jobs' scopes.
+*/
+function registerScheduledEventSeed(container) {
+	container.register(defineProvider(SCHEDULE_INVOCATION_SEED, { useValue: seedScheduledEvent }));
+	container.markGlobalToken(SCHEDULE_INVOCATION_SEED);
+}
+//#endregion
+export { CLOUDFLARE_SCHEDULED_EVENT, cloudflareScheduledEvent, registerScheduledEventSeed };
+
+//# sourceMappingURL=scheduled-event.js.map

package/dist/scheduled-event.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduled-event.js","names":[],"sources":["../src/scheduled-event.ts"],"sourcesContent":["import { InjectionToken, Scope, defineProvider } from '@velajs/vela';\nimport { SCHEDULE_INVOCATION_SEED } from '@velajs/vela/module-kit';\nimport type { ScheduleInvocationSeed, Container } from '@velajs/vela/module-kit';\n\n/**\n * The event a Worker's `scheduled()` export receives. The native\n * `ScheduledController` satisfies it; direct calls (tests, scripts) may omit\n * `scheduledTime`, which then defaults to the current time, and `noRetry`.\n */\nexport interface ScheduledEvent {\n  readonly cron: string;\n  readonly scheduledTime?: number;\n  noRetry?(): void;\n}\n\n/** The Cloudflare trigger behind the current scheduled invocation. */\nexport interface CloudflareScheduledEvent {\n  /** The trigger's exact cron string; it equals the invocation's `expression`. */\n  readonly cron: string;\n  /** The platform's scheduled time in Unix milliseconds. */\n  readonly scheduledTime: number;\n  /**\n   * Ask Cloudflare not to retry this trigger if the invocation fails. Already\n   * bound to the native controller, so it can be passed around or destructured.\n   * A no-op for direct calls that supplied no controller.\n   */\n  readonly noRetry: () => void;\n}\n\n/**\n * Request-scoped Cloudflare view of the scheduled trigger, seeded into each\n * `@Cron` job's invocation scope by the Cloudflare adapter. Inject it where a\n * job needs platform controls such as `noRetry()`; the job's argument stays\n * the portable `ScheduleInvocation`. It resolves only inside a scheduled\n * invocation; resolving it anywhere else throws. A cron job fired on demand\n * (Studio's run-now) receives a synthetic event: `cron` is the job's\n * expression and `noRetry()` does nothing.\n *\n * The token provides itself as request-scoped in every container, so a class\n * that injects it is request-scoped wherever the graph boots (a Worker, a\n * Durable Object, the CLI or a testing module) and is built only for an\n * invocation, never at bootstrap.\n *\n * @example\n * ```ts\n * @Injectable({ scope: Scope.REQUEST })\n * class Reports {\n *   constructor(@Inject(CLOUDFLARE_SCHEDULED_EVENT) private readonly trigger: CloudflareScheduledEvent) {}\n *\n *   @Cron('0 3 * * *', { dialect: 'cloudflare' })\n *   async nightly(tick: CronInvocation) {\n *     if (!(await this.upstreamAvailable(tick.signal))) this.trigger.noRetry();\n *   }\n * }\n * ```\n */\nexport const CLOUDFLARE_SCHEDULED_EVENT = new InjectionToken<CloudflareScheduledEvent>(\n  '@velajs/cloudflare:scheduled-event',\n  {\n    scope: Scope.REQUEST,\n    factory: () => {\n      throw new Error(\n        'CLOUDFLARE_SCHEDULED_EVENT can only be resolved inside a scheduled invocation: ' +\n          'the Cloudflare adapter seeds it into each @Cron job scope for a cron trigger.',\n      );\n    },\n  },\n);\n\n/** @internal Freeze the injected view; `noRetry` keeps the native receiver. */\nexport function cloudflareScheduledEvent(\n  event: ScheduledEvent,\n  scheduledTime: number,\n): CloudflareScheduledEvent {\n  return Object.freeze({\n    cron: event.cron,\n    scheduledTime,\n    noRetry: () => {\n      event.noRetry?.();\n    },\n  });\n}\n\n/**\n * Seeds a cron job fired outside a trigger (Studio's run-now) the way a\n * trigger would: a synthetic event whose `cron` is the invocation's\n * expression, with its `scheduledTime` and a `noRetry()` that does nothing.\n * Interval jobs never run from Workers triggers, so they get no event.\n */\nconst seedScheduledEvent: ScheduleInvocationSeed = (scope, invocation) => {\n  if (invocation.kind !== 'cron') return;\n  scope.setRequestInstance(\n    CLOUDFLARE_SCHEDULED_EVENT,\n    cloudflareScheduledEvent({ cron: invocation.expression }, invocation.scheduledTime),\n  );\n};\n\n/**\n * @internal Provide `SCHEDULE_INVOCATION_SEED`, so jobs fired on demand get a\n * synthetic event. Each trigger seeds the real event into its jobs' scopes.\n */\nexport function registerScheduledEventSeed(container: Container): void {\n  container.register(defineProvider(SCHEDULE_INVOCATION_SEED, { useValue: seedScheduledEvent }));\n  container.markGlobalToken(SCHEDULE_INVOCATION_SEED);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwDA,MAAa,6BAA6B,IAAI,eAC5C,sCACA;CACE,OAAO,MAAM;CACb,eAAe;EACb,MAAM,IAAI,MACR,8JAEF;CACF;AACF,CACF;;AAGA,SAAgB,yBACd,OACA,eAC0B;CAC1B,OAAO,OAAO,OAAO;EACnB,MAAM,MAAM;EACZ;EACA,eAAe;GACb,MAAM,UAAU;EAClB;CACF,CAAC;AACH;;;;;;;AAQA,MAAM,sBAA8C,OAAO,eAAe;CACxE,IAAI,WAAW,SAAS,QAAQ;CAChC,MAAM,mBACJ,4BACA,yBAAyB,EAAE,MAAM,WAAW,WAAW,GAAG,WAAW,aAAa,CACpF;AACF;;;;;AAMA,SAAgB,2BAA2B,WAA4B;CACrE,UAAU,SAAS,eAAe,0BAA0B,EAAE,UAAU,mBAAmB,CAAC,CAAC;CAC7F,UAAU,gBAAgB,wBAAwB;AACpD"}

package/dist/services/flagship-flag.driver.js

@@ -0,0 +1,52 @@
+//#region src/services/flagship-flag.driver.ts
+/**
+* {@link FeatureFlagDriver} backed by a Cloudflare Flagship binding.
+*
+* A thin, honest wrapper: each contract method maps 1:1 onto the binding's
+* corresponding value method, forwarding the caller's `fallback` (the binding's
+* `defaultValue`) and evaluation context. The binding resolves the fallback on
+* evaluation errors; anything the binding *rejects* with (e.g. a `remote: true`
+* dev-proxy tunnel dropping) propagates — `@velajs/feature-flags`'s service owns
+* the never-throw guarantee.
+*
+* Build the driver inside a provider factory with the native environment:
+*
+* ```ts
+* FeatureFlagsModule.forRootAsync({
+*   inject: [ENV],
+*   useFactory: (env: WorkerEnv) => ({ drivers: [flagshipFlagDriver(env.FLAGS)] }),
+* });
+* ```
+*
+* Evaluation ergonomics (the 1:1 binding-method mapping) are ported from the
+* Stratal feature-flags service (MIT, © Temitayo Fadojutimi), reshaped as a
+* bare driver.
+*/
+var FlagshipFlagDriver = class {
+	name;
+	resolve;
+	constructor(binding, options = {}) {
+		this.resolve = typeof binding === "function" ? binding : () => binding;
+		this.name = options.name ?? "flagship";
+	}
+	getBoolean(key, fallback, ctx) {
+		return this.resolve().getBooleanValue(key, fallback, ctx);
+	}
+	getString(key, fallback, ctx) {
+		return this.resolve().getStringValue(key, fallback, ctx);
+	}
+	getNumber(key, fallback, ctx) {
+		return this.resolve().getNumberValue(key, fallback, ctx);
+	}
+	getObject(key, fallback, ctx) {
+		return this.resolve().getObjectValue(key, fallback, ctx);
+	}
+};
+/** Convenience factory for {@link FlagshipFlagDriver}. */
+function flagshipFlagDriver(binding, options) {
+	return new FlagshipFlagDriver(binding, options);
+}
+//#endregion
+export { FlagshipFlagDriver, flagshipFlagDriver };
+
+//# sourceMappingURL=flagship-flag.driver.js.map

package/dist/services/flagship-flag.driver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flagship-flag.driver.js","names":[],"sources":["../../src/services/flagship-flag.driver.ts"],"sourcesContent":["import type { FeatureFlagDriver, FlagContext } from '@velajs/feature-flags';\n\n/**\n * The subset of a Cloudflare **Flagship** binding this driver evaluates against\n * — the four typed value methods. The binding itself returns the supplied\n * `defaultValue` on evaluation errors; transport-level failures reject and are\n * left to propagate (never-throw is the service layer's job, not the driver's).\n *\n * @see https://developers.cloudflare.com/flagship/binding/\n */\nexport interface FlagshipBinding {\n  getBooleanValue(key: string, defaultValue: boolean, context?: FlagContext): Promise<boolean>;\n  getStringValue(key: string, defaultValue: string, context?: FlagContext): Promise<string>;\n  getNumberValue(key: string, defaultValue: number, context?: FlagContext): Promise<number>;\n  getObjectValue(key: string, defaultValue: object, context?: FlagContext): Promise<unknown>;\n}\n\nexport interface FlagshipFlagDriverOptions {\n  /** Driver name used for `use(name)` / default-driver selection. Default `\"flagship\"`. */\n  name?: string;\n}\n\n/**\n * {@link FeatureFlagDriver} backed by a Cloudflare Flagship binding.\n *\n * A thin, honest wrapper: each contract method maps 1:1 onto the binding's\n * corresponding value method, forwarding the caller's `fallback` (the binding's\n * `defaultValue`) and evaluation context. The binding resolves the fallback on\n * evaluation errors; anything the binding *rejects* with (e.g. a `remote: true`\n * dev-proxy tunnel dropping) propagates — `@velajs/feature-flags`'s service owns\n * the never-throw guarantee.\n *\n * Build the driver inside a provider factory with the native environment:\n *\n * ```ts\n * FeatureFlagsModule.forRootAsync({\n *   inject: [ENV],\n *   useFactory: (env: WorkerEnv) => ({ drivers: [flagshipFlagDriver(env.FLAGS)] }),\n * });\n * ```\n *\n * Evaluation ergonomics (the 1:1 binding-method mapping) are ported from the\n * Stratal feature-flags service (MIT, © Temitayo Fadojutimi), reshaped as a\n * bare driver.\n */\nexport class FlagshipFlagDriver implements FeatureFlagDriver {\n  readonly name: string;\n  private readonly resolve: () => FlagshipBinding;\n\n  constructor(\n    binding: FlagshipBinding | (() => FlagshipBinding),\n    options: FlagshipFlagDriverOptions = {},\n  ) {\n    this.resolve = typeof binding === 'function' ? binding : () => binding;\n    this.name = options.name ?? 'flagship';\n  }\n\n  getBoolean(key: string, fallback: boolean, ctx?: FlagContext): Promise<boolean> {\n    return this.resolve().getBooleanValue(key, fallback, ctx);\n  }\n\n  getString(key: string, fallback: string, ctx?: FlagContext): Promise<string> {\n    return this.resolve().getStringValue(key, fallback, ctx);\n  }\n\n  getNumber(key: string, fallback: number, ctx?: FlagContext): Promise<number> {\n    return this.resolve().getNumberValue(key, fallback, ctx);\n  }\n\n  getObject(key: string, fallback: object, ctx?: FlagContext): Promise<unknown> {\n    return this.resolve().getObjectValue(key, fallback, ctx);\n  }\n}\n\n/** Convenience factory for {@link FlagshipFlagDriver}. */\nexport function flagshipFlagDriver(\n  binding: FlagshipBinding | (() => FlagshipBinding),\n  options?: FlagshipFlagDriverOptions,\n): FlagshipFlagDriver {\n  return new FlagshipFlagDriver(binding, options);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AA6CA,IAAa,qBAAb,MAA6D;CAC3D;CACA;CAEA,YACE,SACA,UAAqC,CAAC,GACtC;EACA,KAAK,UAAU,OAAO,YAAY,aAAa,gBAAgB;EAC/D,KAAK,OAAO,QAAQ,QAAQ;CAC9B;CAEA,WAAW,KAAa,UAAmB,KAAqC;EAC9E,OAAO,KAAK,QAAQ,CAAC,CAAC,gBAAgB,KAAK,UAAU,GAAG;CAC1D;CAEA,UAAU,KAAa,UAAkB,KAAoC;EAC3E,OAAO,KAAK,QAAQ,CAAC,CAAC,eAAe,KAAK,UAAU,GAAG;CACzD;CAEA,UAAU,KAAa,UAAkB,KAAoC;EAC3E,OAAO,KAAK,QAAQ,CAAC,CAAC,eAAe,KAAK,UAAU,GAAG;CACzD;CAEA,UAAU,KAAa,UAAkB,KAAqC;EAC5E,OAAO,KAAK,QAAQ,CAAC,CAAC,eAAe,KAAK,UAAU,GAAG;CACzD;AACF;;AAGA,SAAgB,mBACd,SACA,SACoB;CACpB,OAAO,IAAI,mBAAmB,SAAS,OAAO;AAChD"}

package/dist/services/kv-cache.store.js

@@ -0,0 +1,82 @@
+//#region src/services/kv-cache.store.ts
+/**
+* Native KV JSON value store. Metadata retains logical expiry even when KV's
+* physical retention rounds up to its 60-second minimum. Legacy values without
+* metadata remain readable, but cannot safely backfill another tier.
+*/
+var KVCacheStore = class {
+	ns;
+	constructor(ns) {
+		this.ns = ns;
+	}
+	async get(key) {
+		return (await this.getEntry(key))?.value;
+	}
+	async getEntry(key) {
+		const { value, metadata } = await this.ns.getWithMetadata(key, "json");
+		if (value === null) return void 0;
+		if (typeof metadata === "object" && metadata !== null && "velaCacheExpiresAt" in metadata) {
+			const expiresAt = metadata.velaCacheExpiresAt;
+			if (typeof expiresAt !== "number" || !Number.isFinite(expiresAt) || expiresAt <= Date.now()) return void 0;
+			return {
+				value,
+				expiresAt
+			};
+		}
+		return { value };
+	}
+	async set(key, value, ttl) {
+		if (ttl !== void 0 && (!Number.isFinite(ttl) || ttl < 0)) throw new TypeError("Cache TTL must be finite and nonnegative.");
+		if (ttl !== void 0) return this.setEntry(key, {
+			value,
+			expiresAt: Date.now() + ttl * 1e3
+		});
+		await this.ns.put(key, JSON.stringify(value));
+	}
+	async setEntry(key, entry) {
+		if (!Number.isFinite(entry.expiresAt)) throw new TypeError("Cache expiry must be finite.");
+		const remaining = (entry.expiresAt - Date.now()) / 1e3;
+		if (remaining <= 0) return this.del(key);
+		await this.ns.put(key, JSON.stringify(entry.value), {
+			expirationTtl: Math.max(60, Math.ceil(remaining)),
+			metadata: { velaCacheExpiresAt: entry.expiresAt }
+		});
+	}
+	async del(key) {
+		await this.ns.delete(key);
+	}
+	/** Namespace-wide, best effort. Use a dedicated value namespace; never use for scoped invalidation. */
+	async clear() {
+		let cursor;
+		do {
+			const list = await this.ns.list(cursor ? { cursor } : void 0);
+			await Promise.all(list.keys.map((entry) => this.ns.delete(entry.name)));
+			cursor = list.list_complete ? void 0 : list.cursor;
+		} while (cursor);
+	}
+};
+/**
+* Optional, eventually consistent generation store. Use a dedicated KV namespace
+* without TTL/lifecycle cleanup. Never delete/reset generations while entries can
+* survive. Concurrent writes and cached/negative reads prevent strong invalidation;
+* this is unsuitable for strict read-after-write or authorization revocation.
+*/
+var KVCacheInvalidationStore = class {
+	ns;
+	constructor(ns) {
+		this.ns = ns;
+	}
+	async getVersion(key) {
+		const value = await this.ns.get(key, "json");
+		if (value === null) return "initial";
+		if (typeof value !== "string" || value.length === 0 || value.length > 2048) throw new TypeError("Invalid cache generation.");
+		return value;
+	}
+	async invalidate(key) {
+		await this.ns.put(key, JSON.stringify(crypto.randomUUID()));
+	}
+};
+//#endregion
+export { KVCacheInvalidationStore, KVCacheStore };
+
+//# sourceMappingURL=kv-cache.store.js.map

package/dist/services/kv-cache.store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"kv-cache.store.js","names":[],"sources":["../../src/services/kv-cache.store.ts"],"sourcesContent":["import type {\n  AsyncCacheStore,\n  CacheEntryReader,\n  CacheEntryWriter,\n  CacheEntry,\n  CacheInvalidationStore,\n} from '@velajs/vela/cache';\n\n/**\n * Native KV JSON value store. Metadata retains logical expiry even when KV's\n * physical retention rounds up to its 60-second minimum. Legacy values without\n * metadata remain readable, but cannot safely backfill another tier.\n */\nexport class KVCacheStore implements AsyncCacheStore, CacheEntryReader, CacheEntryWriter {\n  constructor(private readonly ns: KVNamespace) {}\n\n  async get(key: string): Promise<unknown> {\n    return (await this.getEntry(key))?.value;\n  }\n\n  async getEntry(key: string): Promise<{ value: unknown; expiresAt?: number } | undefined> {\n    const { value, metadata } = await this.ns.getWithMetadata<unknown, unknown>(key, 'json');\n    if (value === null) return undefined;\n    if (typeof metadata === 'object' && metadata !== null && 'velaCacheExpiresAt' in metadata) {\n      const expiresAt = metadata.velaCacheExpiresAt;\n      if (typeof expiresAt !== 'number' || !Number.isFinite(expiresAt) || expiresAt <= Date.now())\n        return undefined;\n      return { value, expiresAt };\n    }\n    return { value };\n  }\n\n  async set(key: string, value: unknown, ttl?: number): Promise<void> {\n    if (ttl !== undefined && (!Number.isFinite(ttl) || ttl < 0))\n      throw new TypeError('Cache TTL must be finite and nonnegative.');\n    if (ttl !== undefined) return this.setEntry(key, { value, expiresAt: Date.now() + ttl * 1000 });\n    await this.ns.put(key, JSON.stringify(value));\n  }\n\n  async setEntry(key: string, entry: CacheEntry): Promise<void> {\n    if (!Number.isFinite(entry.expiresAt)) throw new TypeError('Cache expiry must be finite.');\n    const remaining = (entry.expiresAt - Date.now()) / 1000;\n    if (remaining <= 0) return this.del(key);\n    await this.ns.put(key, JSON.stringify(entry.value), {\n      expirationTtl: Math.max(60, Math.ceil(remaining)),\n      metadata: { velaCacheExpiresAt: entry.expiresAt },\n    });\n  }\n\n  async del(key: string): Promise<void> {\n    await this.ns.delete(key);\n  }\n\n  /** Namespace-wide, best effort. Use a dedicated value namespace; never use for scoped invalidation. */\n  async clear(): Promise<void> {\n    let cursor: string | undefined;\n    do {\n      const list = await this.ns.list(cursor ? { cursor } : undefined);\n      await Promise.all(list.keys.map((entry) => this.ns.delete(entry.name)));\n      cursor = list.list_complete ? undefined : list.cursor;\n    } while (cursor);\n  }\n}\n\n/**\n * Optional, eventually consistent generation store. Use a dedicated KV namespace\n * without TTL/lifecycle cleanup. Never delete/reset generations while entries can\n * survive. Concurrent writes and cached/negative reads prevent strong invalidation;\n * this is unsuitable for strict read-after-write or authorization revocation.\n */\nexport class KVCacheInvalidationStore implements CacheInvalidationStore {\n  constructor(private readonly ns: KVNamespace) {}\n  async getVersion(key: string): Promise<string> {\n    const value: unknown = await this.ns.get(key, 'json');\n    if (value === null) return 'initial';\n    if (typeof value !== 'string' || value.length === 0 || value.length > 2048)\n      throw new TypeError('Invalid cache generation.');\n    return value;\n  }\n  async invalidate(key: string): Promise<void> {\n    await this.ns.put(key, JSON.stringify(crypto.randomUUID()));\n  }\n}\n"],"mappings":";;;;;;AAaA,IAAa,eAAb,MAAyF;CAC1D;CAA7B,YAAY,IAAkC;EAAjB,KAAA,KAAA;CAAkB;CAE/C,MAAM,IAAI,KAA+B;EACvC,QAAQ,MAAM,KAAK,SAAS,GAAG,EAAA,EAAI;CACrC;CAEA,MAAM,SAAS,KAA0E;EACvF,MAAM,EAAE,OAAO,aAAa,MAAM,KAAK,GAAG,gBAAkC,KAAK,MAAM;EACvF,IAAI,UAAU,MAAM,OAAO,KAAA;EAC3B,IAAI,OAAO,aAAa,YAAY,aAAa,QAAQ,wBAAwB,UAAU;GACzF,MAAM,YAAY,SAAS;GAC3B,IAAI,OAAO,cAAc,YAAY,CAAC,OAAO,SAAS,SAAS,KAAK,aAAa,KAAK,IAAI,GACxF,OAAO,KAAA;GACT,OAAO;IAAE;IAAO;GAAU;EAC5B;EACA,OAAO,EAAE,MAAM;CACjB;CAEA,MAAM,IAAI,KAAa,OAAgB,KAA6B;EAClE,IAAI,QAAQ,KAAA,MAAc,CAAC,OAAO,SAAS,GAAG,KAAK,MAAM,IACvD,MAAM,IAAI,UAAU,2CAA2C;EACjE,IAAI,QAAQ,KAAA,GAAW,OAAO,KAAK,SAAS,KAAK;GAAE;GAAO,WAAW,KAAK,IAAI,IAAI,MAAM;EAAK,CAAC;EAC9F,MAAM,KAAK,GAAG,IAAI,KAAK,KAAK,UAAU,KAAK,CAAC;CAC9C;CAEA,MAAM,SAAS,KAAa,OAAkC;EAC5D,IAAI,CAAC,OAAO,SAAS,MAAM,SAAS,GAAG,MAAM,IAAI,UAAU,8BAA8B;EACzF,MAAM,aAAa,MAAM,YAAY,KAAK,IAAI,KAAK;EACnD,IAAI,aAAa,GAAG,OAAO,KAAK,IAAI,GAAG;EACvC,MAAM,KAAK,GAAG,IAAI,KAAK,KAAK,UAAU,MAAM,KAAK,GAAG;GAClD,eAAe,KAAK,IAAI,IAAI,KAAK,KAAK,SAAS,CAAC;GAChD,UAAU,EAAE,oBAAoB,MAAM,UAAU;EAClD,CAAC;CACH;CAEA,MAAM,IAAI,KAA4B;EACpC,MAAM,KAAK,GAAG,OAAO,GAAG;CAC1B;;CAGA,MAAM,QAAuB;EAC3B,IAAI;EACJ,GAAG;GACD,MAAM,OAAO,MAAM,KAAK,GAAG,KAAK,SAAS,EAAE,OAAO,IAAI,KAAA,CAAS;GAC/D,MAAM,QAAQ,IAAI,KAAK,KAAK,KAAK,UAAU,KAAK,GAAG,OAAO,MAAM,IAAI,CAAC,CAAC;GACtE,SAAS,KAAK,gBAAgB,KAAA,IAAY,KAAK;EACjD,SAAS;CACX;AACF;;;;;;;AAQA,IAAa,2BAAb,MAAwE;CACzC;CAA7B,YAAY,IAAkC;EAAjB,KAAA,KAAA;CAAkB;CAC/C,MAAM,WAAW,KAA8B;EAC7C,MAAM,QAAiB,MAAM,KAAK,GAAG,IAAI,KAAK,MAAM;EACpD,IAAI,UAAU,MAAM,OAAO;EAC3B,IAAI,OAAO,UAAU,YAAY,MAAM,WAAW,KAAK,MAAM,SAAS,MACpE,MAAM,IAAI,UAAU,2BAA2B;EACjD,OAAO;CACT;CACA,MAAM,WAAW,KAA4B;EAC3C,MAAM,KAAK,GAAG,IAAI,KAAK,KAAK,UAAU,OAAO,WAAW,CAAC,CAAC;CAC5D;AACF"}

package/dist/services/kv-flag.driver.js

@@ -0,0 +1,62 @@
+//#region src/services/kv-flag.driver.ts
+/**
+* Cloudflare KV-backed {@link FeatureFlagDriver}. Flags are stored as JSON
+* values under an optional key prefix and read with `get(key, 'json')`. Reads
+* are type-checked against the requested type: a missing key or a value of the
+* wrong JSON type returns the caller's `fallback`. KV has no targeting, so the
+* evaluation context is ignored.
+*
+* The driver stays honest — it does **not** swallow errors. A KV failure (or a
+* `SyntaxError` from a malformed stored value) propagates; the never-throw
+* guarantee lives in `@velajs/feature-flags`'s service layer.
+*
+* Placed like {@link KVCacheStore}: construct it in a wiring factory over a
+* resolved {@link KVNamespace}.
+*
+* ```ts
+* FeatureFlagsModule.forRootAsync({
+*   inject: [ENV],
+*   useFactory: (env: WorkerEnv) => ({ drivers: [new KvFlagDriver(env.CACHE, { prefix: 'flag:' })] }),
+* });
+* ```
+*/
+var KvFlagDriver = class {
+	ns;
+	name;
+	prefix;
+	constructor(ns, options = {}) {
+		this.ns = ns;
+		this.name = options.name ?? "kv";
+		this.prefix = options.prefix ?? "";
+	}
+	getBoolean(key, fallback, _ctx) {
+		return this.read(key, fallback, (v) => typeof v === "boolean");
+	}
+	getString(key, fallback, _ctx) {
+		return this.read(key, fallback, (v) => typeof v === "string");
+	}
+	getNumber(key, fallback, _ctx) {
+		return this.read(key, fallback, (v) => typeof v === "number");
+	}
+	getObject(key, fallback, _ctx) {
+		return this.read(key, fallback, (v) => typeof v === "object" && v !== null);
+	}
+	/**
+	* Reads and JSON-parses the (prefixed) key, returning the parsed value only
+	* when `matches` accepts its type; otherwise the caller's fallback. A missing
+	* key reads as `null` → fallback. Read/parse errors are left to propagate.
+	*/
+	async read(key, fallback, matches) {
+		const value = await this.ns.get(this.prefix + key, "json");
+		if (value === null || value === void 0) return fallback;
+		return matches(value) ? value : fallback;
+	}
+};
+/** Convenience factory for {@link KvFlagDriver}. */
+function kvFlagDriver(kv, options) {
+	return new KvFlagDriver(kv, options);
+}
+//#endregion
+export { KvFlagDriver, kvFlagDriver };
+
+//# sourceMappingURL=kv-flag.driver.js.map

package/dist/services/kv-flag.driver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"kv-flag.driver.js","names":[],"sources":["../../src/services/kv-flag.driver.ts"],"sourcesContent":["import type { FeatureFlagDriver, FlagContext } from '@velajs/feature-flags';\n\nexport interface KvFlagDriverOptions {\n  /** Driver name used for `use(name)` / default-driver selection. Default `\"kv\"`. */\n  name?: string;\n  /** Prefix prepended to every flag key before the KV read. Default `\"\"` (none). */\n  prefix?: string;\n}\n\n/**\n * Cloudflare KV-backed {@link FeatureFlagDriver}. Flags are stored as JSON\n * values under an optional key prefix and read with `get(key, 'json')`. Reads\n * are type-checked against the requested type: a missing key or a value of the\n * wrong JSON type returns the caller's `fallback`. KV has no targeting, so the\n * evaluation context is ignored.\n *\n * The driver stays honest — it does **not** swallow errors. A KV failure (or a\n * `SyntaxError` from a malformed stored value) propagates; the never-throw\n * guarantee lives in `@velajs/feature-flags`'s service layer.\n *\n * Placed like {@link KVCacheStore}: construct it in a wiring factory over a\n * resolved {@link KVNamespace}.\n *\n * ```ts\n * FeatureFlagsModule.forRootAsync({\n *   inject: [ENV],\n *   useFactory: (env: WorkerEnv) => ({ drivers: [new KvFlagDriver(env.CACHE, { prefix: 'flag:' })] }),\n * });\n * ```\n */\nexport class KvFlagDriver implements FeatureFlagDriver {\n  readonly name: string;\n  private readonly prefix: string;\n\n  constructor(\n    private readonly ns: KVNamespace,\n    options: KvFlagDriverOptions = {},\n  ) {\n    this.name = options.name ?? 'kv';\n    this.prefix = options.prefix ?? '';\n  }\n\n  getBoolean(key: string, fallback: boolean, _ctx?: FlagContext): Promise<boolean> {\n    return this.read(key, fallback, (v) => typeof v === 'boolean');\n  }\n\n  getString(key: string, fallback: string, _ctx?: FlagContext): Promise<string> {\n    return this.read(key, fallback, (v) => typeof v === 'string');\n  }\n\n  getNumber(key: string, fallback: number, _ctx?: FlagContext): Promise<number> {\n    return this.read(key, fallback, (v) => typeof v === 'number');\n  }\n\n  getObject(key: string, fallback: object, _ctx?: FlagContext): Promise<unknown> {\n    return this.read(key, fallback, (v) => typeof v === 'object' && v !== null);\n  }\n\n  /**\n   * Reads and JSON-parses the (prefixed) key, returning the parsed value only\n   * when `matches` accepts its type; otherwise the caller's fallback. A missing\n   * key reads as `null` → fallback. Read/parse errors are left to propagate.\n   */\n  private async read<T>(\n    key: string,\n    fallback: T,\n    matches: (value: unknown) => value is T,\n  ): Promise<T> {\n    const value = await this.ns.get(this.prefix + key, 'json');\n    if (value === null || value === undefined) return fallback;\n    return matches(value) ? value : fallback;\n  }\n}\n\n/** Convenience factory for {@link KvFlagDriver}. */\nexport function kvFlagDriver(kv: KVNamespace, options?: KvFlagDriverOptions): KvFlagDriver {\n  return new KvFlagDriver(kv, options);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AA8BA,IAAa,eAAb,MAAuD;CAKlC;CAJnB;CACA;CAEA,YACE,IACA,UAA+B,CAAC,GAChC;EAFiB,KAAA,KAAA;EAGjB,KAAK,OAAO,QAAQ,QAAQ;EAC5B,KAAK,SAAS,QAAQ,UAAU;CAClC;CAEA,WAAW,KAAa,UAAmB,MAAsC;EAC/E,OAAO,KAAK,KAAK,KAAK,WAAW,MAAM,OAAO,MAAM,SAAS;CAC/D;CAEA,UAAU,KAAa,UAAkB,MAAqC;EAC5E,OAAO,KAAK,KAAK,KAAK,WAAW,MAAM,OAAO,MAAM,QAAQ;CAC9D;CAEA,UAAU,KAAa,UAAkB,MAAqC;EAC5E,OAAO,KAAK,KAAK,KAAK,WAAW,MAAM,OAAO,MAAM,QAAQ;CAC9D;CAEA,UAAU,KAAa,UAAkB,MAAsC;EAC7E,OAAO,KAAK,KAAK,KAAK,WAAW,MAAM,OAAO,MAAM,YAAY,MAAM,IAAI;CAC5E;;;;;;CAOA,MAAc,KACZ,KACA,UACA,SACY;EACZ,MAAM,QAAQ,MAAM,KAAK,GAAG,IAAI,KAAK,SAAS,KAAK,MAAM;EACzD,IAAI,UAAU,QAAQ,UAAU,KAAA,GAAW,OAAO;EAClD,OAAO,QAAQ,KAAK,IAAI,QAAQ;CAClC;AACF;;AAGA,SAAgB,aAAa,IAAiB,SAA6C;CACzF,OAAO,IAAI,aAAa,IAAI,OAAO;AACrC"}

package/dist/storage/r2-storage.driver.js

@@ -0,0 +1,67 @@
+import { encodeStorageKeyClaim } from "./storage-key-claim.js";
+import { STORAGE_SIGNED_URL_PURPOSE, signUrl } from "@velajs/vela/security";
+//#region src/storage/r2-storage.driver.ts
+/** Base path of the StorageController presign-proxy route. */
+const STORAGE_ROUTE_BASE = "/storage";
+/** {@link StorageDriver} over a Cloudflare R2 bucket. */
+var R2StorageDriver = class {
+	config;
+	constructor(config) {
+		this.config = config;
+	}
+	async upload(body, path, options) {
+		await this.config.bucket.put(path, body, {
+			httpMetadata: options.mimeType ? { contentType: options.mimeType } : void 0,
+			customMetadata: options.metadata
+		});
+		return {
+			path,
+			disk: this.config.disk,
+			size: options.size,
+			mimeType: options.mimeType ?? "application/octet-stream",
+			uploadedAt: /* @__PURE__ */ new Date()
+		};
+	}
+	async download(path) {
+		const obj = await this.config.bucket.get(path);
+		if (!obj) throw new Error(`Storage object not found at "${path}".`);
+		return {
+			toStream: () => obj.body,
+			toArrayBuffer: () => obj.arrayBuffer(),
+			toText: () => obj.text(),
+			contentType: obj.httpMetadata?.contentType ?? "application/octet-stream",
+			size: obj.size,
+			metadata: obj.customMetadata
+		};
+	}
+	async delete(path) {
+		await this.config.bucket.delete(path);
+	}
+	async exists(path) {
+		return await this.config.bucket.head(path) !== null;
+	}
+	async getPresignedUrl(path, method, expiresIn) {
+		if (!this.config.secret) throw new Error("A signing secret is required for presigned URLs (set APP_SECRET).");
+		if (!Number.isSafeInteger(expiresIn) || expiresIn <= 0) throw new Error(`Invalid presigned URL expiry: ${expiresIn}s (must be a positive safe integer).`);
+		const claim = encodeStorageKeyClaim(path);
+		const routePath = `${STORAGE_ROUTE_BASE}/${encodeURIComponent(this.config.disk)}`;
+		const query = new URLSearchParams({
+			key: claim,
+			method
+		});
+		return {
+			url: await signUrl(`${routePath}?${query}`, this.config.secret, {
+				expiresIn,
+				method,
+				purpose: STORAGE_SIGNED_URL_PURPOSE
+			}),
+			method,
+			expiresIn,
+			expiresAt: new Date(Date.now() + expiresIn * 1e3)
+		};
+	}
+};
+//#endregion
+export { R2StorageDriver, STORAGE_ROUTE_BASE };
+
+//# sourceMappingURL=r2-storage.driver.js.map

package/dist/storage/r2-storage.driver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"r2-storage.driver.js","names":[],"sources":["../../src/storage/r2-storage.driver.ts"],"sourcesContent":["import type {\n  DownloadResult,\n  PresignedUrlResult,\n  PresignMethod,\n  StorageBody,\n  StorageDriver,\n  UploadOptions,\n  UploadResult,\n} from '@velajs/vela/storage';\nimport { signUrl, STORAGE_SIGNED_URL_PURPOSE } from '@velajs/vela/security';\nimport { encodeStorageKeyClaim } from './storage-key-claim';\n\n/** Base path of the StorageController presign-proxy route. */\nexport const STORAGE_ROUTE_BASE = '/storage';\n\nexport interface R2StorageDriverConfig {\n  disk: string;\n  bucket: R2Bucket;\n  /** HMAC secret for presigned URLs (typically env.APP_SECRET). */\n  secret?: string;\n}\n\n/** {@link StorageDriver} over a Cloudflare R2 bucket. */\nexport class R2StorageDriver implements StorageDriver {\n  constructor(private readonly config: R2StorageDriverConfig) {}\n\n  async upload(body: StorageBody, path: string, options: UploadOptions): Promise<UploadResult> {\n    await this.config.bucket.put(\n      path,\n      body as ReadableStream | ArrayBuffer | ArrayBufferView | string | Blob | null,\n      {\n        httpMetadata: options.mimeType ? { contentType: options.mimeType } : undefined,\n        customMetadata: options.metadata,\n      },\n    );\n    return {\n      path,\n      disk: this.config.disk,\n      size: options.size,\n      mimeType: options.mimeType ?? 'application/octet-stream',\n      uploadedAt: new Date(),\n    };\n  }\n\n  async download(path: string): Promise<DownloadResult> {\n    const obj = await this.config.bucket.get(path);\n    if (!obj) throw new Error(`Storage object not found at \"${path}\".`);\n    return {\n      toStream: () => obj.body as ReadableStream,\n      toArrayBuffer: () => obj.arrayBuffer(),\n      toText: () => obj.text(),\n      contentType: obj.httpMetadata?.contentType ?? 'application/octet-stream',\n      size: obj.size,\n      metadata: obj.customMetadata,\n    };\n  }\n\n  async delete(path: string): Promise<void> {\n    await this.config.bucket.delete(path);\n  }\n\n  async exists(path: string): Promise<boolean> {\n    return (await this.config.bucket.head(path)) !== null;\n  }\n\n  async getPresignedUrl(\n    path: string,\n    method: PresignMethod,\n    expiresIn: number,\n  ): Promise<PresignedUrlResult> {\n    if (!this.config.secret) {\n      throw new Error('A signing secret is required for presigned URLs (set APP_SECRET).');\n    }\n    // Defend the direct-driver path too: a non-finite/non-positive expiry would\n    // make signUrl omit `expires`, yielding a never-expiring URL.\n    if (!Number.isSafeInteger(expiresIn) || expiresIn <= 0) {\n      throw new Error(\n        `Invalid presigned URL expiry: ${expiresIn}s (must be a positive safe integer).`,\n      );\n    }\n    // The object key is an opaque signed query claim, never a URL path. This\n    // prevents WHATWG path normalization / multi-decode behavior from turning\n    // an encoded key into a different storage capability.\n    const claim = encodeStorageKeyClaim(path);\n    const routePath = `${STORAGE_ROUTE_BASE}/${encodeURIComponent(this.config.disk)}`;\n    const query = new URLSearchParams({ key: claim, method });\n    const url = await signUrl(`${routePath}?${query}`, this.config.secret, {\n      expiresIn,\n      method,\n      purpose: STORAGE_SIGNED_URL_PURPOSE,\n    });\n    return { url, method, expiresIn, expiresAt: new Date(Date.now() + expiresIn * 1000) };\n  }\n}\n"],"mappings":";;;;AAaA,MAAa,qBAAqB;;AAUlC,IAAa,kBAAb,MAAsD;CACvB;CAA7B,YAAY,QAAgD;EAA/B,KAAA,SAAA;CAAgC;CAE7D,MAAM,OAAO,MAAmB,MAAc,SAA+C;EAC3F,MAAM,KAAK,OAAO,OAAO,IACvB,MACA,MACA;GACE,cAAc,QAAQ,WAAW,EAAE,aAAa,QAAQ,SAAS,IAAI,KAAA;GACrE,gBAAgB,QAAQ;EAC1B,CACF;EACA,OAAO;GACL;GACA,MAAM,KAAK,OAAO;GAClB,MAAM,QAAQ;GACd,UAAU,QAAQ,YAAY;GAC9B,4BAAY,IAAI,KAAK;EACvB;CACF;CAEA,MAAM,SAAS,MAAuC;EACpD,MAAM,MAAM,MAAM,KAAK,OAAO,OAAO,IAAI,IAAI;EAC7C,IAAI,CAAC,KAAK,MAAM,IAAI,MAAM,gCAAgC,KAAK,GAAG;EAClE,OAAO;GACL,gBAAgB,IAAI;GACpB,qBAAqB,IAAI,YAAY;GACrC,cAAc,IAAI,KAAK;GACvB,aAAa,IAAI,cAAc,eAAe;GAC9C,MAAM,IAAI;GACV,UAAU,IAAI;EAChB;CACF;CAEA,MAAM,OAAO,MAA6B;EACxC,MAAM,KAAK,OAAO,OAAO,OAAO,IAAI;CACtC;CAEA,MAAM,OAAO,MAAgC;EAC3C,OAAQ,MAAM,KAAK,OAAO,OAAO,KAAK,IAAI,MAAO;CACnD;CAEA,MAAM,gBACJ,MACA,QACA,WAC6B;EAC7B,IAAI,CAAC,KAAK,OAAO,QACf,MAAM,IAAI,MAAM,mEAAmE;EAIrF,IAAI,CAAC,OAAO,cAAc,SAAS,KAAK,aAAa,GACnD,MAAM,IAAI,MACR,iCAAiC,UAAU,qCAC7C;EAKF,MAAM,QAAQ,sBAAsB,IAAI;EACxC,MAAM,YAAY,GAAG,mBAAmB,GAAG,mBAAmB,KAAK,OAAO,IAAI;EAC9E,MAAM,QAAQ,IAAI,gBAAgB;GAAE,KAAK;GAAO;EAAO,CAAC;EAMxD,OAAO;GAAE,KAAA,MALS,QAAQ,GAAG,UAAU,GAAG,SAAS,KAAK,OAAO,QAAQ;IACrE;IACA;IACA,SAAS;GACX,CAAC;GACa;GAAQ;GAAW,WAAW,IAAI,KAAK,KAAK,IAAI,IAAI,YAAY,GAAI;EAAE;CACtF;AACF"}

package/dist/storage/storage-key-claim.js

@@ -0,0 +1,74 @@
+//#region src/storage/storage-key-claim.ts
+/** R2-compatible object-key claim bound. Keeps decode work predictably small. */
+const MAX_STORAGE_KEY_BYTES = 1024;
+const BASE64URL_RE = /^[A-Za-z0-9_-]+$/;
+const ROOT_TOKEN_PATTERNS = {
+	date: "\\d{4}-\\d{2}-\\d{2}",
+	year: "\\d{4}",
+	month: "(?:0[1-9]|1[0-2])",
+	day: "(?:0[1-9]|[12]\\d|3[01])",
+	uuid: "[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}"
+};
+/** Encode an object key as an opaque, canonical base64url query claim. */
+function encodeStorageKeyClaim(key) {
+	const bytes = new TextEncoder().encode(key);
+	if (bytes.byteLength === 0 || bytes.byteLength > MAX_STORAGE_KEY_BYTES) throw new Error(`Storage key must be 1–${MAX_STORAGE_KEY_BYTES} UTF-8 bytes`);
+	let binary = "";
+	for (const byte of bytes) binary += String.fromCharCode(byte);
+	return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+/** Decode exactly one canonical base64url layer. Malformed/non-UTF-8 claims return undefined. */
+function decodeStorageKeyClaim(claim) {
+	try {
+		if (claim.length === 0 || claim.length > Math.ceil(MAX_STORAGE_KEY_BYTES * 4 / 3) || !BASE64URL_RE.test(claim) || claim.length % 4 === 1) return;
+		const base64 = claim.replace(/-/g, "+").replace(/_/g, "/");
+		const padded = base64 + "=".repeat((4 - base64.length % 4) % 4);
+		const binary = atob(padded);
+		const bytes = new Uint8Array(new ArrayBuffer(binary.length));
+		for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
+		if (bytes.byteLength === 0 || bytes.byteLength > MAX_STORAGE_KEY_BYTES) return void 0;
+		const decoded = new TextDecoder("utf-8", {
+			fatal: true,
+			ignoreBOM: false
+		}).decode(bytes);
+		return encodeStorageKeyClaim(decoded) === claim ? decoded : void 0;
+	} catch {
+		return;
+	}
+}
+function isDotSegment(segment) {
+	let decoded = segment;
+	for (let i = 0; i < 2; i++) {
+		if (decoded === "" || decoded === "." || decoded === "..") return true;
+		try {
+			const next = decodeURIComponent(decoded);
+			if (next === decoded) break;
+			decoded = next;
+		} catch {
+			break;
+		}
+	}
+	return decoded === "" || decoded === "." || decoded === "..";
+}
+function rootSegmentPattern(segment) {
+	let pattern = "";
+	let cursor = 0;
+	for (const match of segment.matchAll(/\{(date|year|month|day|uuid)\}/g)) {
+		pattern += segment.slice(cursor, match.index).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+		pattern += ROOT_TOKEN_PATTERNS[match[1]];
+		cursor = match.index + match[0].length;
+	}
+	pattern += segment.slice(cursor).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	return pattern;
+}
+/** Assert a canonical key is beneath a static or templated configured root. */
+function isStorageKeyWithinRoot(key, root) {
+	const segments = (root ?? "").split(/[/\\]+/).filter((segment) => !isDotSegment(segment));
+	if (segments.length === 0) return key.length > 0;
+	const rootPattern = segments.map(rootSegmentPattern).join("/");
+	return new RegExp(`^(?:${rootPattern})(?:/|$)`).test(key);
+}
+//#endregion
+export { MAX_STORAGE_KEY_BYTES, decodeStorageKeyClaim, encodeStorageKeyClaim, isStorageKeyWithinRoot };
+
+//# sourceMappingURL=storage-key-claim.js.map

package/dist/storage/storage-key-claim.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-key-claim.js","names":[],"sources":["../../src/storage/storage-key-claim.ts"],"sourcesContent":["/** R2-compatible object-key claim bound. Keeps decode work predictably small. */\nexport const MAX_STORAGE_KEY_BYTES = 1024;\n\nconst BASE64URL_RE = /^[A-Za-z0-9_-]+$/;\nconst ROOT_TOKEN_PATTERNS: Record<string, string> = {\n  date: '\\\\d{4}-\\\\d{2}-\\\\d{2}',\n  year: '\\\\d{4}',\n  month: '(?:0[1-9]|1[0-2])',\n  day: '(?:0[1-9]|[12]\\\\d|3[01])',\n  uuid: '[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}',\n};\n\n/** Encode an object key as an opaque, canonical base64url query claim. */\nexport function encodeStorageKeyClaim(key: string): string {\n  const bytes = new TextEncoder().encode(key);\n  if (bytes.byteLength === 0 || bytes.byteLength > MAX_STORAGE_KEY_BYTES) {\n    throw new Error(`Storage key must be 1–${MAX_STORAGE_KEY_BYTES} UTF-8 bytes`);\n  }\n  let binary = '';\n  for (const byte of bytes) binary += String.fromCharCode(byte);\n  return btoa(binary).replace(/\\+/g, '-').replace(/\\//g, '_').replace(/=+$/, '');\n}\n\n/** Decode exactly one canonical base64url layer. Malformed/non-UTF-8 claims return undefined. */\nexport function decodeStorageKeyClaim(claim: string): string | undefined {\n  try {\n    if (\n      claim.length === 0 ||\n      claim.length > Math.ceil((MAX_STORAGE_KEY_BYTES * 4) / 3) ||\n      !BASE64URL_RE.test(claim) ||\n      claim.length % 4 === 1\n    ) {\n      return undefined;\n    }\n    const base64 = claim.replace(/-/g, '+').replace(/_/g, '/');\n    const padded = base64 + '='.repeat((4 - (base64.length % 4)) % 4);\n    const binary = atob(padded);\n    const bytes = new Uint8Array(new ArrayBuffer(binary.length));\n    for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);\n    if (bytes.byteLength === 0 || bytes.byteLength > MAX_STORAGE_KEY_BYTES) return undefined;\n    const decoded = new TextDecoder('utf-8', { fatal: true, ignoreBOM: false }).decode(bytes);\n    return encodeStorageKeyClaim(decoded) === claim ? decoded : undefined;\n  } catch {\n    return undefined;\n  }\n}\n\nfunction isDotSegment(segment: string): boolean {\n  let decoded = segment;\n  for (let i = 0; i < 2; i++) {\n    if (decoded === '' || decoded === '.' || decoded === '..') return true;\n    try {\n      const next = decodeURIComponent(decoded);\n      if (next === decoded) break;\n      decoded = next;\n    } catch {\n      break;\n    }\n  }\n  return decoded === '' || decoded === '.' || decoded === '..';\n}\n\nfunction rootSegmentPattern(segment: string): string {\n  let pattern = '';\n  let cursor = 0;\n  for (const match of segment.matchAll(/\\{(date|year|month|day|uuid)\\}/g)) {\n    pattern += segment.slice(cursor, match.index).replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');\n    pattern += ROOT_TOKEN_PATTERNS[match[1]!]!;\n    cursor = match.index! + match[0].length;\n  }\n  pattern += segment.slice(cursor).replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');\n  return pattern;\n}\n\n/** Assert a canonical key is beneath a static or templated configured root. */\nexport function isStorageKeyWithinRoot(key: string, root: string | undefined): boolean {\n  const segments = (root ?? '').split(/[/\\\\]+/).filter((segment) => !isDotSegment(segment));\n  if (segments.length === 0) return key.length > 0;\n  const rootPattern = segments.map(rootSegmentPattern).join('/');\n  return new RegExp(`^(?:${rootPattern})(?:/|$)`).test(key);\n}\n"],"mappings":";;AACA,MAAa,wBAAwB;AAErC,MAAM,eAAe;AACrB,MAAM,sBAA8C;CAClD,MAAM;CACN,MAAM;CACN,OAAO;CACP,KAAK;CACL,MAAM;AACR;;AAGA,SAAgB,sBAAsB,KAAqB;CACzD,MAAM,QAAQ,IAAI,YAAY,CAAC,CAAC,OAAO,GAAG;CAC1C,IAAI,MAAM,eAAe,KAAK,MAAM,aAAa,uBAC/C,MAAM,IAAI,MAAM,yBAAyB,sBAAsB,aAAa;CAE9E,IAAI,SAAS;CACb,KAAK,MAAM,QAAQ,OAAO,UAAU,OAAO,aAAa,IAAI;CAC5D,OAAO,KAAK,MAAM,CAAC,CAAC,QAAQ,OAAO,GAAG,CAAC,CAAC,QAAQ,OAAO,GAAG,CAAC,CAAC,QAAQ,OAAO,EAAE;AAC/E;;AAGA,SAAgB,sBAAsB,OAAmC;CACvE,IAAI;EACF,IACE,MAAM,WAAW,KACjB,MAAM,SAAS,KAAK,KAAM,wBAAwB,IAAK,CAAC,KACxD,CAAC,aAAa,KAAK,KAAK,KACxB,MAAM,SAAS,MAAM,GAErB;EAEF,MAAM,SAAS,MAAM,QAAQ,MAAM,GAAG,CAAC,CAAC,QAAQ,MAAM,GAAG;EACzD,MAAM,SAAS,SAAS,IAAI,QAAQ,IAAK,OAAO,SAAS,KAAM,CAAC;EAChE,MAAM,SAAS,KAAK,MAAM;EAC1B,MAAM,QAAQ,IAAI,WAAW,IAAI,YAAY,OAAO,MAAM,CAAC;EAC3D,KAAK,IAAI,IAAI,GAAG,IAAI,OAAO,QAAQ,KAAK,MAAM,KAAK,OAAO,WAAW,CAAC;EACtE,IAAI,MAAM,eAAe,KAAK,MAAM,aAAa,uBAAuB,OAAO,KAAA;EAC/E,MAAM,UAAU,IAAI,YAAY,SAAS;GAAE,OAAO;GAAM,WAAW;EAAM,CAAC,CAAC,CAAC,OAAO,KAAK;EACxF,OAAO,sBAAsB,OAAO,MAAM,QAAQ,UAAU,KAAA;CAC9D,QAAQ;EACN;CACF;AACF;AAEA,SAAS,aAAa,SAA0B;CAC9C,IAAI,UAAU;CACd,KAAK,IAAI,IAAI,GAAG,IAAI,GAAG,KAAK;EAC1B,IAAI,YAAY,MAAM,YAAY,OAAO,YAAY,MAAM,OAAO;EAClE,IAAI;GACF,MAAM,OAAO,mBAAmB,OAAO;GACvC,IAAI,SAAS,SAAS;GACtB,UAAU;EACZ,QAAQ;GACN;EACF;CACF;CACA,OAAO,YAAY,MAAM,YAAY,OAAO,YAAY;AAC1D;AAEA,SAAS,mBAAmB,SAAyB;CACnD,IAAI,UAAU;CACd,IAAI,SAAS;CACb,KAAK,MAAM,SAAS,QAAQ,SAAS,iCAAiC,GAAG;EACvE,WAAW,QAAQ,MAAM,QAAQ,MAAM,KAAK,CAAC,CAAC,QAAQ,uBAAuB,MAAM;EACnF,WAAW,oBAAoB,MAAM;EACrC,SAAS,MAAM,QAAS,MAAM,EAAE,CAAC;CACnC;CACA,WAAW,QAAQ,MAAM,MAAM,CAAC,CAAC,QAAQ,uBAAuB,MAAM;CACtE,OAAO;AACT;;AAGA,SAAgB,uBAAuB,KAAa,MAAmC;CACrF,MAAM,YAAY,QAAQ,GAAA,CAAI,MAAM,QAAQ,CAAC,CAAC,QAAQ,YAAY,CAAC,aAAa,OAAO,CAAC;CACxF,IAAI,SAAS,WAAW,GAAG,OAAO,IAAI,SAAS;CAC/C,MAAM,cAAc,SAAS,IAAI,kBAAkB,CAAC,CAAC,KAAK,GAAG;CAC7D,OAAO,IAAI,OAAO,OAAO,YAAY,SAAS,CAAC,CAAC,KAAK,GAAG;AAC1D"}