stratal 0.0.13 → 0.0.15

package/dist/validation-Dbt-snjx.mjs

@@ -0,0 +1,194 @@
+import { n as __reExport, t as __exportAll } from "./chunk-D1SwGrFN.mjs";
+import { OpenAPIHono, z } from "@hono/zod-openapi";
+import { ZodError } from "zod";
+import { AsyncLocalStorage } from "node:async_hooks";
+//#region src/i18n/validation/validation.error-map.ts
+/**
+* Type guards for narrowing Zod v4 issue types
+*/
+function isInvalidType(issue) {
+	return issue.code === "invalid_type";
+}
+function isTooBig(issue) {
+	return issue.code === "too_big";
+}
+function isTooSmall(issue) {
+	return issue.code === "too_small";
+}
+function isInvalidFormat(issue) {
+	return issue.code === "invalid_format";
+}
+function isNotMultipleOf(issue) {
+	return issue.code === "not_multiple_of";
+}
+function isUnrecognizedKeys(issue) {
+	return issue.code === "unrecognized_keys";
+}
+function isInvalidUnion(issue) {
+	return issue.code === "invalid_union";
+}
+function isInvalidKey(issue) {
+	return issue.code === "invalid_key";
+}
+/**
+* Maps Zod issue codes to zodI18n message keys
+* Adapted for Zod v4's simpler issue code system
+*/
+function getMessageKey(issue) {
+	if (isInvalidType(issue)) {
+		if (issue.input === void 0) return "zodI18n.errors.required";
+		return "zodI18n.errors.invalid_type";
+	}
+	if (isTooSmall(issue)) return `zodI18n.errors.too_small.${issue.origin || "string"}.${issue.exact ? "exact" : issue.inclusive ? "inclusive" : "not_inclusive"}`;
+	if (isTooBig(issue)) return `zodI18n.errors.too_big.${issue.origin || "string"}.${issue.exact ? "exact" : issue.inclusive ? "inclusive" : "not_inclusive"}`;
+	if (isInvalidFormat(issue)) return `zodI18n.errors.invalid_string.${issue.format}`;
+	if (isNotMultipleOf(issue)) return "zodI18n.errors.not_multiple_of";
+	if (isUnrecognizedKeys(issue)) return "zodI18n.errors.unrecognized_keys";
+	if (isInvalidUnion(issue)) return "zodI18n.errors.invalid_union";
+	if (isInvalidKey(issue)) return "zodI18n.errors.invalid_enum_value";
+	return "zodI18n.errors.custom.default";
+}
+/**
+* Extracts interpolation parameters from Zod issue
+* Uses proper type narrowing for v4
+*/
+function getMessageParams(issue) {
+	const params = {};
+	if (isInvalidType(issue)) {
+		params.expected = issue.expected;
+		params.received = String(issue.input);
+		return params;
+	}
+	if (isUnrecognizedKeys(issue)) {
+		params.keys = issue.keys.join(", ");
+		return params;
+	}
+	if (isInvalidKey(issue)) return params;
+	if (isInvalidFormat(issue)) {
+		params.validation = issue.format;
+		if ("prefix" in issue) params.startsWith = issue.prefix;
+		if ("suffix" in issue) params.endsWith = issue.suffix;
+		if ("includes" in issue) params.includes = issue.includes;
+		if (issue.pattern) params.pattern = issue.pattern;
+		return params;
+	}
+	if (isTooSmall(issue)) {
+		params.minimum = issue.minimum;
+		params.type = issue.origin;
+		if (issue.origin === "date") params.minimum = new Date(Number(issue.minimum)).toLocaleDateString();
+		return params;
+	}
+	if (isTooBig(issue)) {
+		params.maximum = issue.maximum;
+		params.type = issue.origin;
+		if (issue.origin === "date") params.maximum = new Date(Number(issue.maximum)).toLocaleDateString();
+		return params;
+	}
+	if (isNotMultipleOf(issue)) {
+		params.multipleOf = issue.divisor;
+		return params;
+	}
+	return params;
+}
+/**
+* Creates a Zod error map that uses i18n for translation
+* Uses Zod v4 native $ZodErrorMap signature (no ctx parameter)
+*/
+function createI18nErrorMap(getContext) {
+	return (issue) => {
+		const messageKey = getMessageKey(issue);
+		const messageParams = getMessageParams(issue);
+		const context = getContext();
+		if (!context) return { message: "Invalid input" };
+		return { message: context.t(messageKey, messageParams) };
+	};
+}
+//#endregion
+//#region src/i18n/validation/validation.context.ts
+/**
+* AsyncLocalStorage for storing request-scoped ErrorMapContext
+* Allows error map to access I18nService without passing through function calls
+*/
+const errorMapContextStorage = new AsyncLocalStorage();
+/**
+* Gets the current error map context from AsyncLocalStorage
+*/
+function getErrorMapContext() {
+	return errorMapContextStorage.getStore();
+}
+/**
+* Backend error map that accesses I18nService from AsyncLocalStorage
+* Must be initialized in router middleware after locale detection
+*/
+const backendErrorMap = createI18nErrorMap(getErrorMapContext);
+/**
+* Runs a function within an error map context
+* Used by router middleware to provide I18nService to validation
+*
+* @example
+* ```typescript
+* router.use('*', async (c, next) => {
+*   const i18nService = c.get('i18nService')
+*   const locale = c.get('locale')
+*
+*   return runWithErrorMapContext(
+*     {
+*       t: (key, params) => i18nService.t(key, params),
+*       locale,
+*     },
+*     () => next()
+*   )
+* })
+* ```
+*/
+function runWithErrorMapContext(context, fn) {
+	return errorMapContextStorage.run(context, fn);
+}
+//#endregion
+//#region src/i18n/validation/with-i18n.ts
+/**
+* Type-safe helper for creating custom Zod error messages with i18n support (Backend)
+*
+* Usage with .refine():
+* ```typescript
+* const schema = z.string().refine(
+*   (val) => val.length > 5,
+*   withI18n('validation.minLength', { min: 5 })
+* )
+* ```
+*
+* Usage with built-in validators:
+* ```typescript
+* const schema = z.string().min(5, withI18n('validation.minLength', { min: 5 }))
+* const schema = z.string().email(withI18n('validation.email'))
+* ```
+*
+* Note: This is the backend version using AsyncLocalStorage.
+* For frontend, use withI18nFrontend from the frontend validation module
+*
+* @param key - Message key from shared i18n messages (type-safe via MessageKeys)
+* @param params - Optional interpolation parameters for the message
+* @returns Zod error configuration object with translated message
+*/
+function withI18n(key, params) {
+	return { error: () => {
+		const context = errorMapContextStorage.getStore();
+		return context ? context.t(key, params) : "Invalid input";
+	} };
+}
+//#endregion
+//#region src/i18n/validation/index.ts
+var validation_exports = /* @__PURE__ */ __exportAll({
+	OpenAPIHono: () => OpenAPIHono,
+	ZodError: () => ZodError,
+	backendErrorMap: () => backendErrorMap,
+	runWithErrorMapContext: () => runWithErrorMapContext,
+	withI18n: () => withI18n,
+	z: () => z
+});
+import * as import__hono_zod_openapi from "@hono/zod-openapi";
+__reExport(validation_exports, import__hono_zod_openapi);
+//#endregion
+export { withI18n as a, z as i, ZodError as n, backendErrorMap as o, validation_exports as r, runWithErrorMapContext as s, OpenAPIHono as t };
+
+//# sourceMappingURL=validation-Dbt-snjx.mjs.map

package/dist/validation-Dbt-snjx.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation-Dbt-snjx.mjs","names":[],"sources":["../src/i18n/validation/validation.error-map.ts","../src/i18n/validation/validation.context.ts","../src/i18n/validation/with-i18n.ts","../src/i18n/validation/index.ts"],"sourcesContent":["import type {\n  $ZodErrorMap,\n  $ZodIssueInvalidKey,\n  $ZodIssueInvalidStringFormat,\n  $ZodIssueInvalidType,\n  $ZodIssueInvalidUnion,\n  $ZodIssueNotMultipleOf,\n  $ZodIssueTooBig,\n  $ZodIssueTooSmall,\n  $ZodIssueUnrecognizedKeys,\n  $ZodRawIssue,\n} from 'zod/v4/core'\nimport type { MessageKeys } from '../i18n.types'\nimport type { ErrorMapContext } from './validation.types'\n\n/**\n * Type guards for narrowing Zod v4 issue types\n */\nfunction isInvalidType(issue: $ZodRawIssue): issue is $ZodRawIssue<$ZodIssueInvalidType> {\n  return issue.code === 'invalid_type'\n}\n\nfunction isTooBig(issue: $ZodRawIssue): issue is $ZodRawIssue<$ZodIssueTooBig> {\n  return issue.code === 'too_big'\n}\n\nfunction isTooSmall(issue: $ZodRawIssue): issue is $ZodRawIssue<$ZodIssueTooSmall> {\n  return issue.code === 'too_small'\n}\n\nfunction isInvalidFormat(issue: $ZodRawIssue): issue is $ZodRawIssue<$ZodIssueInvalidStringFormat> {\n  return issue.code === 'invalid_format'\n}\n\nfunction isNotMultipleOf(issue: $ZodRawIssue): issue is $ZodRawIssue<$ZodIssueNotMultipleOf> {\n  return issue.code === 'not_multiple_of'\n}\n\nfunction isUnrecognizedKeys(issue: $ZodRawIssue): issue is $ZodRawIssue<$ZodIssueUnrecognizedKeys> {\n  return issue.code === 'unrecognized_keys'\n}\n\nfunction isInvalidUnion(issue: $ZodRawIssue): issue is $ZodRawIssue<$ZodIssueInvalidUnion> {\n  return issue.code === 'invalid_union'\n}\n\nfunction isInvalidKey(issue: $ZodRawIssue): issue is $ZodRawIssue<$ZodIssueInvalidKey> {\n  return issue.code === 'invalid_key'\n}\n\n/**\n * Maps Zod issue codes to zodI18n message keys\n * Adapted for Zod v4's simpler issue code system\n */\nfunction getMessageKey(issue: $ZodRawIssue): MessageKeys {\n  if (isInvalidType(issue)) {\n    if (issue.input === undefined) {\n      return 'zodI18n.errors.required'\n    }\n    return 'zodI18n.errors.invalid_type'\n  }\n\n  if (isTooSmall(issue)) {\n    const typeKey = issue.origin || 'string'\n    const exactKey = issue.exact\n      ? 'exact'\n      : issue.inclusive\n        ? 'inclusive'\n        : 'not_inclusive'\n    return `zodI18n.errors.too_small.${typeKey}.${exactKey}` as MessageKeys\n  }\n\n  if (isTooBig(issue)) {\n    const typeKey = issue.origin || 'string'\n    const exactKey = issue.exact\n      ? 'exact'\n      : issue.inclusive\n        ? 'inclusive'\n        : 'not_inclusive'\n    return `zodI18n.errors.too_big.${typeKey}.${exactKey}` as MessageKeys\n  }\n\n  if (isInvalidFormat(issue)) {\n    // Map v4's format to v3-style validation keys\n    return `zodI18n.errors.invalid_string.${issue.format}` as MessageKeys\n  }\n\n  if (isNotMultipleOf(issue)) {\n    return 'zodI18n.errors.not_multiple_of'\n  }\n\n  if (isUnrecognizedKeys(issue)) {\n    return 'zodI18n.errors.unrecognized_keys'\n  }\n\n  if (isInvalidUnion(issue)) {\n    return 'zodI18n.errors.invalid_union'\n  }\n\n  if (isInvalidKey(issue)) {\n    // v4: Replaces invalid_enum_value, invalid_literal\n    return 'zodI18n.errors.invalid_enum_value'\n  }\n\n  // invalid_element, invalid_value, or unknown codes\n  return 'zodI18n.errors.custom.default'\n}\n\n/**\n * Extracts interpolation parameters from Zod issue\n * Uses proper type narrowing for v4\n */\nfunction getMessageParams(issue: $ZodRawIssue): Record<string, unknown> {\n  const params: Record<string, unknown> = {}\n\n  if (isInvalidType(issue)) {\n    params.expected = issue.expected\n    params.received = String(issue.input)\n    return params\n  }\n\n  if (isUnrecognizedKeys(issue)) {\n    params.keys = issue.keys.join(', ')\n    return params\n  }\n\n  if (isInvalidKey(issue)) {\n    // v4: For enums and records\n    // Since v4 doesn't have options field, we'll use generic message\n    return params\n  }\n\n  if (isInvalidFormat(issue)) {\n    params.validation = issue.format\n\n    // Check for specific string format issues with additional fields\n    if ('prefix' in issue) {\n      params.startsWith = (issue as { prefix?: string }).prefix\n    }\n    if ('suffix' in issue) {\n      params.endsWith = (issue as { suffix?: string }).suffix\n    }\n    if ('includes' in issue) {\n      params.includes = (issue as { includes?: string }).includes\n    }\n    if (issue.pattern) {\n      params.pattern = issue.pattern\n    }\n\n    return params\n  }\n\n  if (isTooSmall(issue)) {\n    params.minimum = issue.minimum\n    params.type = issue.origin\n    if (issue.origin === 'date') {\n      params.minimum = new Date(Number(issue.minimum)).toLocaleDateString()\n    }\n    return params\n  }\n\n  if (isTooBig(issue)) {\n    params.maximum = issue.maximum\n    params.type = issue.origin\n    if (issue.origin === 'date') {\n      params.maximum = new Date(Number(issue.maximum)).toLocaleDateString()\n    }\n    return params\n  }\n\n  if (isNotMultipleOf(issue)) {\n    params.multipleOf = issue.divisor\n    return params\n  }\n\n  return params\n}\n\n/**\n * Creates a Zod error map that uses i18n for translation\n * Uses Zod v4 native $ZodErrorMap signature (no ctx parameter)\n */\nexport function createI18nErrorMap(getContext: () => ErrorMapContext | undefined): $ZodErrorMap {\n  return (issue: $ZodRawIssue): { message: string } => {\n    // Get message key and params for this issue\n    const messageKey = getMessageKey(issue)\n    const messageParams = getMessageParams(issue)\n\n    // Get translation context\n    const context = getContext()\n\n    if (!context) {\n      // Fallback: Use English messages directly\n      // This handles config validation at startup, tests, etc.\n      return { message: 'Invalid input' }\n    }\n\n    // Normal flow: Use context-aware i18n (respects user locale)\n    return {\n      message: context.t(messageKey, messageParams),\n    }\n  }\n}\n","import { AsyncLocalStorage } from 'node:async_hooks'\nimport type { ErrorMapContext } from './validation.types'\nimport { createI18nErrorMap } from './validation.error-map'\n\n/**\n * AsyncLocalStorage for storing request-scoped ErrorMapContext\n * Allows error map to access I18nService without passing through function calls\n */\nexport const errorMapContextStorage = new AsyncLocalStorage<ErrorMapContext>()\n\n/**\n * Gets the current error map context from AsyncLocalStorage\n */\nfunction getErrorMapContext(): ErrorMapContext | undefined {\n  return errorMapContextStorage.getStore()\n}\n\n/**\n * Backend error map that accesses I18nService from AsyncLocalStorage\n * Must be initialized in router middleware after locale detection\n */\nexport const backendErrorMap = createI18nErrorMap(getErrorMapContext)\n\n/**\n * Runs a function within an error map context\n * Used by router middleware to provide I18nService to validation\n *\n * @example\n * ```typescript\n * router.use('*', async (c, next) => {\n *   const i18nService = c.get('i18nService')\n *   const locale = c.get('locale')\n *\n *   return runWithErrorMapContext(\n *     {\n *       t: (key, params) => i18nService.t(key, params),\n *       locale,\n *     },\n *     () => next()\n *   )\n * })\n * ```\n */\nexport function runWithErrorMapContext<T>(\n  context: ErrorMapContext,\n  fn: () => T\n): T {\n  return errorMapContextStorage.run(context, fn)\n}\n","import type { MessageKeys } from '../i18n.types'\nimport { errorMapContextStorage } from './validation.context'\n\n/**\n * Type-safe helper for creating custom Zod error messages with i18n support (Backend)\n *\n * Usage with .refine():\n * ```typescript\n * const schema = z.string().refine(\n *   (val) => val.length > 5,\n *   withI18n('validation.minLength', { min: 5 })\n * )\n * ```\n *\n * Usage with built-in validators:\n * ```typescript\n * const schema = z.string().min(5, withI18n('validation.minLength', { min: 5 }))\n * const schema = z.string().email(withI18n('validation.email'))\n * ```\n *\n * Note: This is the backend version using AsyncLocalStorage.\n * For frontend, use withI18nFrontend from the frontend validation module\n *\n * @param key - Message key from shared i18n messages (type-safe via MessageKeys)\n * @param params - Optional interpolation parameters for the message\n * @returns Zod error configuration object with translated message\n */\nexport function withI18n(\n  key: MessageKeys,\n  params?: Record<string, unknown>\n): { error: () => string } {\n  return {\n    error: () => {\n      // Get i18n context from AsyncLocalStorage (backend)\n      // This is set by the router middleware before validation\n      const context = errorMapContextStorage.getStore()\n\n      // Translate using context if available, otherwise fallback to generic message\n      const message = context\n        ? context.t(key, params as Record<string, string | number> | undefined)\n        : 'Invalid input'\n\n      return message\n    },\n  }\n}\n","// Consolidated zod - single source from @hono/zod-openapi (superset of zod)\nexport { OpenAPIHono, z } from '@hono/zod-openapi'\nexport type * from 'zod'\nexport { ZodError } from 'zod'\n\n// OpenAPI utilities\nexport * from '@hono/zod-openapi'\nexport type { OpenAPIObject, PathItemObject } from 'openapi3-ts/oas30'\n\n// Helpers\nexport { withI18n } from './with-i18n'\n\n// Backend utilities\nexport { backendErrorMap, runWithErrorMapContext } from './validation.context'\n\n// Types\nexport type { ErrorMapContext, I18nErrorMetadata, LocaleProvider, ZodCustomIssue } from './validation.types'\n\n"],"mappings":"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"}

package/dist/websocket/index.d.mts

@@ -0,0 +1,168 @@
+import { Et as ControllerOptions, Nt as RouterEnv, Tt as RouterContext, s as ApplicationError, wt as ContextQueryResult } from "../index-D69rxo8H.mjs";
+import { t as Constructor } from "../types-Cu4jkeiH.mjs";
+import { Context } from "hono";
+import { WSContext, WSContext as WSContext$1, WSEvents, WSMessageReceive, WSReadyState, WSReadyState as WSReadyState$1 } from "hono/ws";
+
+//#region src/websocket/types.d.ts
+/**
+ * Gateway options for @Gateway() decorator
+ * Subset of ControllerOptions relevant to WebSocket gateways (no OpenAPI-specific fields)
+ */
+type GatewayOptions = Pick<ControllerOptions, 'version'>;
+//#endregion
+//#region src/websocket/decorators/gateway.decorator.d.ts
+/**
+ * Gateway decorator for WebSocket route registration
+ *
+ * Marks a class as a WebSocket gateway and stores route metadata.
+ * Reuses the same metadata key as @Controller for middleware compatibility —
+ * `getControllerRoute()`, `forRoutes()`, and the entire middleware system work
+ * with zero changes.
+ *
+ * @param route - WebSocket route path (e.g., '/ws/chat')
+ *
+ * @example
+ * ```typescript
+ * import { type GatewayContext, Gateway, OnMessage, OnClose } from 'stratal/websocket'
+ *
+ * @Gateway('/ws/chat')
+ * class ChatGateway {
+ *   @OnMessage()
+ *   handleMessage(evt: MessageEvent, ctx: GatewayContext) {
+ *     ctx.send('ack')
+ *   }
+ *
+ *   @OnClose()
+ *   handleClose(evt: CloseEvent, ctx: GatewayContext) {
+ *     console.log('closed')
+ *   }
+ * }
+ * ```
+ */
+declare function Gateway(route: string, options?: GatewayOptions): <T extends Constructor>(target: T) => T;
+/**
+ * Check if a class is a WebSocket gateway
+ *
+ * @param target - Class constructor or instance
+ * @returns true if the class is decorated with @Gateway
+ */
+declare function isGateway(target: object): boolean;
+//#endregion
+//#region src/websocket/decorators/ws-event.decorator.d.ts
+/**
+ * Marks a method as the WebSocket message handler
+ *
+ * @example
+ * ```typescript
+ * @Gateway('/ws/chat')
+ * class ChatGateway {
+ *   @OnMessage()
+ *   handleMessage(evt: MessageEvent, ctx: GatewayContext) {
+ *     ctx.send(evt.data)
+ *   }
+ * }
+ * ```
+ */
+declare function OnMessage(): MethodDecorator;
+/**
+ * Marks a method as the WebSocket close handler
+ *
+ * @example
+ * ```typescript
+ * @Gateway('/ws/chat')
+ * class ChatGateway {
+ *   @OnClose()
+ *   handleClose(evt: CloseEvent, ctx: GatewayContext) {
+ *     console.log('closed')
+ *   }
+ * }
+ * ```
+ */
+declare function OnClose(): MethodDecorator;
+/**
+ * Marks a method as the WebSocket error handler
+ *
+ * @example
+ * ```typescript
+ * @Gateway('/ws/chat')
+ * class ChatGateway {
+ *   @OnError()
+ *   handleError(evt: Event, ctx: GatewayContext) {
+ *     console.error('WebSocket error', evt)
+ *   }
+ * }
+ * ```
+ */
+declare function OnError(): MethodDecorator;
+/**
+ * Get the method name decorated with @OnMessage
+ */
+declare function getWsOnMessageMethod(target: Constructor): string | undefined;
+/**
+ * Get the method name decorated with @OnClose
+ */
+declare function getWsOnCloseMethod(target: Constructor): string | undefined;
+/**
+ * Get the method name decorated with @OnError
+ */
+declare function getWsOnErrorMethod(target: Constructor): string | undefined;
+//#endregion
+//#region src/websocket/errors/websocket-body-not-available.error.d.ts
+declare class WebSocketBodyNotAvailableError extends ApplicationError {
+  constructor();
+}
+//#endregion
+//#region src/websocket/errors/websocket-duplicate-event-handler.error.d.ts
+declare class WebSocketDuplicateEventHandlerError extends ApplicationError {
+  constructor(decorator: string, existingMethod: string);
+}
+//#endregion
+//#region src/websocket/gateway-context.d.ts
+/**
+ * WebSocket gateway context
+ *
+ * Extends RouterContext with WebSocket-specific methods.
+ * Inherits `getContainer()`, `param()`, `query()`, `header()`, `getLocale()`
+ * from RouterContext. HTTP response methods (`json()`, `redirect()`, etc.) are
+ * inherited but harmless post-upgrade.
+ *
+ * @example
+ * ```typescript
+ * @OnMessage()
+ * handleMessage(evt: MessageEvent, ctx: GatewayContext) {
+ *   ctx.send('ack')           // convenience method
+ *   ctx.header('Authorization') // upgrade request headers
+ * }
+ * ```
+ */
+declare class GatewayContext extends RouterContext {
+  readonly ws: WSContext$1;
+  constructor(c: Context<RouterEnv>, ws: WSContext$1);
+  /** Send data through the WebSocket connection */
+  send(data: string | ArrayBuffer | Uint8Array<ArrayBuffer>): void;
+  /** Close the WebSocket connection */
+  close(code?: number, reason?: string): void;
+  /** Current WebSocket ready state */
+  get readyState(): WSReadyState$1;
+  /**
+   * Get route parameter value from the raw request (no OpenAPI validation)
+   *
+   * @param key - Parameter name (e.g., 'id' for /ws/chat/:id)
+   */
+  param(key: string): string;
+  /**
+   * Get query parameter value from the raw request (no OpenAPI validation)
+   *
+   * @param key - Query parameter name
+   */
+  query<R extends Record<string, unknown> | undefined = undefined, K extends string | undefined = undefined>(key?: K): ContextQueryResult<R, K>;
+  /**
+   * Request body is not available in WebSocket gateways
+   *
+   * @throws WebSocketBodyNotAvailableError always — WebSocket upgrade requests do not have a body
+   */
+  body<T>(): Promise<T>;
+}
+//#endregion
+export { Gateway, GatewayContext, type GatewayOptions, OnClose, OnError, OnMessage, type WSContext, type WSEvents, type WSMessageReceive, type WSReadyState, WebSocketBodyNotAvailableError, WebSocketDuplicateEventHandlerError, getWsOnCloseMethod, getWsOnErrorMethod, getWsOnMessageMethod, isGateway };
+//# sourceMappingURL=index.d.mts.map

package/dist/websocket/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/websocket/types.ts","../../src/websocket/decorators/gateway.decorator.ts","../../src/websocket/decorators/ws-event.decorator.ts","../../src/websocket/errors/websocket-body-not-available.error.ts","../../src/websocket/errors/websocket-duplicate-event-handler.error.ts","../../src/websocket/gateway-context.ts"],"mappings":";;;;;;;;;;KAMY,cAAA,GAAiB,IAAA,CAAK,iBAAA;;;;;;;;AAAlC;;;;;;;;AC+BA;;;;;;;;;;;;;;;iBAAgB,OAAA,CAAQ,KAAA,UAAe,OAAA,GAAU,cAAA,cACpB,WAAA,EAAa,MAAA,EAAQ,CAAA,KAAC,CAAA;;;;AAiBnD;;;iBAAgB,SAAA,CAAU,MAAA;;;;;;;;;ADjD1B;;;;;;;;iBE4BgB,SAAA,CAAA,GAAa,eAAA;;;;;;;;;;;;;;;iBAsBb,OAAA,CAAA,GAAW,eAAA;;;;ADD3B;;;;;;;;ACrBA;;;iBA0CgB,OAAA,CAAA,GAAW,eAAA;;AApB3B;;iBA6BgB,oBAAA,CAAqB,MAAA,EAAQ,WAAA;;;AAT7C;iBAgBgB,kBAAA,CAAmB,MAAA,EAAQ,WAAA;;;;iBAO3B,kBAAA,CAAmB,MAAA,EAAQ,WAAA;;;cCjG9B,8BAAA,SAAuC,gBAAA;EAAA,WAAA,CAAA;AAAA;;;cCAvC,mCAAA,SAA4C,gBAAA;cAC3C,SAAA,UAAmB,cAAA;AAAA;;;;;AJGjC;;;;;;;;AC+BA;;;;;;;cIba,cAAA,SAAuB,aAAA;EAAA,SACiB,EAAA,EAAI,WAAA;cAA3C,CAAA,EAAG,OAAA,CAAQ,SAAA,GAA4B,EAAA,EAAI,WAAA;EJYR;EIP/C,IAAA,CAAK,IAAA,WAAe,WAAA,GAAc,UAAA,CAAW,WAAA;EJQ5B;EIHjB,KAAA,CAAM,IAAA,WAAe,MAAA;EJG2B;EAAA,IIE5C,UAAA,CAAA,GAAc,cAAA;EJF+B;;;AAiBnD;;EINW,KAAA,CAAM,GAAA;EJMS;;;;;EIGf,KAAA,WAAgB,MAAA,oFAAA,CAA2F,GAAA,GAAM,CAAA,GAAI,kBAAA,CAAmB,CAAA,EAAG,CAAA;EHxB7H;;;;AAsBzB;EGcW,IAAA,GAAA,CAAA,GAAW,OAAA,CAAQ,CAAA;AAAA"}

package/dist/websocket/index.mjs

@@ -0,0 +1,6 @@
+import "../errors-CtCi1wn6.mjs";
+import "../decorate-D5j-d9_z.mjs";
+import "../logger-BR1-s1Um.mjs";
+import "../router-context-BLn4PrRG.mjs";
+import { a as OnMessage, c as getWsOnMessageMethod, d as isGateway, i as OnError, l as WebSocketDuplicateEventHandlerError, n as WebSocketBodyNotAvailableError, o as getWsOnCloseMethod, r as OnClose, s as getWsOnErrorMethod, t as GatewayContext, u as Gateway } from "../gateway-context-90CQEQDR.mjs";
+export { Gateway, GatewayContext, OnClose, OnError, OnMessage, WebSocketBodyNotAvailableError, WebSocketDuplicateEventHandlerError, getWsOnCloseMethod, getWsOnErrorMethod, getWsOnMessageMethod, isGateway };

package/dist/workers/index.d.mts

@@ -0,0 +1,90 @@
+import { $t as Container, Ht as StratalEnv } from "../index-D69rxo8H.mjs";
+import { DurableObject, WorkerEntrypoint, WorkflowEntrypoint } from "cloudflare:workers";
+
+//#region src/workers/run-in-scope.d.ts
+/**
+ * Shared helper that creates a request-scoped DI container by accessing the
+ * Stratal Application via the static singleton.
+ *
+ * Works with Durable Objects, Workflows, and WorkerEntrypoints.
+ */
+declare function runInScope<T>(callback: (container: Container) => T | Promise<T>): Promise<T>;
+//#endregion
+//#region src/workers/stratal-durable-object.d.ts
+/**
+ * Base class for Durable Objects with full DI access.
+ *
+ * Extends Cloudflare's `DurableObject` and provides a `runInScope()` helper
+ * that creates a request-scoped container with `DurableObjectState` and
+ * `DurableObjectId` tokens registered.
+ *
+ * @example
+ * ```typescript
+ * import { StratalDurableObject } from 'stratal/workers'
+ *
+ * export class Counter extends StratalDurableObject {
+ *   async increment() {
+ *     return this.runInScope(async (container) => {
+ *       const svc = container.resolve(CounterService)
+ *       return svc.increment()
+ *     })
+ *   }
+ * }
+ * ```
+ */
+declare abstract class StratalDurableObject<Env extends StratalEnv = StratalEnv> extends DurableObject<Env> {
+  protected runInScope<T>(callback: (container: Container) => T | Promise<T>): Promise<T>;
+}
+//#endregion
+//#region src/workers/stratal-worker-entrypoint.d.ts
+/**
+ * Base class for Cloudflare WorkerEntrypoints (Service Bindings / RPC) with full DI access.
+ *
+ * Extends Cloudflare's `WorkerEntrypoint` and provides a `runInScope()` helper
+ * that creates a request-scoped DI container.
+ *
+ * @example
+ * ```typescript
+ * import { StratalWorkerEntrypoint } from 'stratal/workers'
+ *
+ * export class AuthRpc extends StratalWorkerEntrypoint {
+ *   async verifyToken(token: string) {
+ *     return this.runInScope(async (container) => {
+ *       const auth = container.resolve(AuthService)
+ *       return auth.verify(token)
+ *     })
+ *   }
+ * }
+ * ```
+ */
+declare abstract class StratalWorkerEntrypoint<Env extends StratalEnv = StratalEnv> extends WorkerEntrypoint<Env> {
+  protected runInScope<T>(callback: (container: Container) => T | Promise<T>): Promise<T>;
+}
+//#endregion
+//#region src/workers/stratal-workflow.d.ts
+/**
+ * Base class for Cloudflare Workflows with full DI access.
+ *
+ * Extends Cloudflare's `WorkflowEntrypoint` and provides a `runInScope()` helper
+ * that creates a request-scoped DI container.
+ *
+ * @example
+ * ```typescript
+ * import { StratalWorkflow } from 'stratal/workers'
+ *
+ * export class MyWorkflow extends StratalWorkflow<Env, { userId: string }> {
+ *   async run(event: WorkflowEvent<{ userId: string }>, step: WorkflowStep) {
+ *     await this.runInScope(async (container) => {
+ *       const svc = container.resolve(UserService)
+ *       await svc.process(event.payload.userId)
+ *     })
+ *   }
+ * }
+ * ```
+ */
+declare abstract class StratalWorkflow<Env extends StratalEnv = StratalEnv, Params = unknown> extends WorkflowEntrypoint<Env, Params> {
+  protected runInScope<T>(callback: (container: Container) => T | Promise<T>): Promise<T>;
+}
+//#endregion
+export { StratalDurableObject, StratalWorkerEntrypoint, StratalWorkflow, runInScope };
+//# sourceMappingURL=index.d.mts.map

package/dist/workers/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/workers/run-in-scope.ts","../../src/workers/stratal-durable-object.ts","../../src/workers/stratal-worker-entrypoint.ts","../../src/workers/stratal-workflow.ts"],"mappings":";;;;;;;;AASA;;iBAAsB,UAAA,GAAA,CACpB,QAAA,GAAW,SAAA,EAAW,SAAA,KAAc,CAAA,GAAI,OAAA,CAAQ,CAAA,IAC/C,OAAA,CAAQ,CAAA;;;;;AAFX;;;;;;;;;;;;;;;;;;;uBCkBsB,oBAAA,aACR,UAAA,GAAa,UAAA,UACjB,aAAA,CAAc,GAAA;EAAA,UACN,UAAA,GAAA,CACd,QAAA,GAAW,SAAA,EAAW,SAAA,KAAc,CAAA,GAAI,OAAA,CAAQ,CAAA,IAC/C,OAAA,CAAQ,CAAA;AAAA;;;;;ADvBb;;;;;;;;;;;;;;;;;;uBEgBsB,uBAAA,aACR,UAAA,GAAa,UAAA,UACjB,gBAAA,CAAiB,GAAA;EAAA,UACf,UAAA,GAAA,CACR,QAAA,GAAW,SAAA,EAAW,SAAA,KAAc,CAAA,GAAI,OAAA,CAAQ,CAAA,IAC/C,OAAA,CAAQ,CAAA;AAAA;;;;;AFrBb;;;;;;;;;;;;;;;;;;uBGgBsB,eAAA,aACR,UAAA,GAAa,UAAA,4BAEjB,kBAAA,CAAmB,GAAA,EAAK,MAAA;EAAA,UACtB,UAAA,GAAA,CACR,QAAA,GAAW,SAAA,EAAW,SAAA,KAAc,CAAA,GAAI,OAAA,CAAQ,CAAA,IAC/C,OAAA,CAAQ,CAAA;AAAA"}

package/dist/workers/index.mjs

@@ -0,0 +1,122 @@
+import "../errors-CtCi1wn6.mjs";
+import { l as DI_TOKENS } from "../decorate-D5j-d9_z.mjs";
+import "../logger-BR1-s1Um.mjs";
+import "../module-BH7t7BGG.mjs";
+import "../events-CXl-o1Ad.mjs";
+import "../command-DG_u5ob2.mjs";
+import "../is-command-MZDCH-0T.mjs";
+import "../is-seeder-BN9Ej1r7.mjs";
+import "../middleware-iRhNjsPH.mjs";
+import "../router-context-BLn4PrRG.mjs";
+import "../cron-manager-BRh86QCS.mjs";
+import "../validation-Dbt-snjx.mjs";
+import "../i18n.module-qNrpIVts.mjs";
+import "../guards-DMbsAxSX.mjs";
+import "../gateway-context-90CQEQDR.mjs";
+import "../quarry-registry-BPmKVjhG.mjs";
+import "../queue.module-BdXWUvIM.mjs";
+import "../seeder-DatfjJvU.mjs";
+import { t as Stratal } from "../stratal-Cm0Yy8v4.mjs";
+import { DurableObject, WorkerEntrypoint, WorkflowEntrypoint } from "cloudflare:workers";
+//#region src/workers/run-in-scope.ts
+/**
+* Shared helper that creates a request-scoped DI container by accessing the
+* Stratal Application via the static singleton.
+*
+* Works with Durable Objects, Workflows, and WorkerEntrypoints.
+*/
+async function runInScope(callback) {
+	const app = await Stratal.resolveApplication();
+	const mockCtx = app.createMockRouterContext("en");
+	return app.container.runInRequestScope(mockCtx, callback);
+}
+//#endregion
+//#region src/workers/stratal-durable-object.ts
+/**
+* Base class for Durable Objects with full DI access.
+*
+* Extends Cloudflare's `DurableObject` and provides a `runInScope()` helper
+* that creates a request-scoped container with `DurableObjectState` and
+* `DurableObjectId` tokens registered.
+*
+* @example
+* ```typescript
+* import { StratalDurableObject } from 'stratal/workers'
+*
+* export class Counter extends StratalDurableObject {
+*   async increment() {
+*     return this.runInScope(async (container) => {
+*       const svc = container.resolve(CounterService)
+*       return svc.increment()
+*     })
+*   }
+* }
+* ```
+*/
+var StratalDurableObject = class extends DurableObject {
+	async runInScope(callback) {
+		return runInScope(async (requestContainer) => {
+			requestContainer.registerValue(DI_TOKENS.DurableObjectState, this.ctx);
+			requestContainer.registerValue(DI_TOKENS.DurableObjectId, this.ctx.id);
+			return callback(requestContainer);
+		});
+	}
+};
+//#endregion
+//#region src/workers/stratal-worker-entrypoint.ts
+/**
+* Base class for Cloudflare WorkerEntrypoints (Service Bindings / RPC) with full DI access.
+*
+* Extends Cloudflare's `WorkerEntrypoint` and provides a `runInScope()` helper
+* that creates a request-scoped DI container.
+*
+* @example
+* ```typescript
+* import { StratalWorkerEntrypoint } from 'stratal/workers'
+*
+* export class AuthRpc extends StratalWorkerEntrypoint {
+*   async verifyToken(token: string) {
+*     return this.runInScope(async (container) => {
+*       const auth = container.resolve(AuthService)
+*       return auth.verify(token)
+*     })
+*   }
+* }
+* ```
+*/
+var StratalWorkerEntrypoint = class extends WorkerEntrypoint {
+	runInScope(callback) {
+		return runInScope(callback);
+	}
+};
+//#endregion
+//#region src/workers/stratal-workflow.ts
+/**
+* Base class for Cloudflare Workflows with full DI access.
+*
+* Extends Cloudflare's `WorkflowEntrypoint` and provides a `runInScope()` helper
+* that creates a request-scoped DI container.
+*
+* @example
+* ```typescript
+* import { StratalWorkflow } from 'stratal/workers'
+*
+* export class MyWorkflow extends StratalWorkflow<Env, { userId: string }> {
+*   async run(event: WorkflowEvent<{ userId: string }>, step: WorkflowStep) {
+*     await this.runInScope(async (container) => {
+*       const svc = container.resolve(UserService)
+*       await svc.process(event.payload.userId)
+*     })
+*   }
+* }
+* ```
+*/
+var StratalWorkflow = class extends WorkflowEntrypoint {
+	runInScope(callback) {
+		return runInScope(callback);
+	}
+};
+//#endregion
+export { StratalDurableObject, StratalWorkerEntrypoint, StratalWorkflow, runInScope };
+
+//# sourceMappingURL=index.mjs.map

package/dist/workers/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":[],"sources":["../../src/workers/run-in-scope.ts","../../src/workers/stratal-durable-object.ts","../../src/workers/stratal-worker-entrypoint.ts","../../src/workers/stratal-workflow.ts"],"sourcesContent":["import type { Container } from '../di/container'\nimport { Stratal } from '../stratal'\n\n/**\n * Shared helper that creates a request-scoped DI container by accessing the\n * Stratal Application via the static singleton.\n *\n * Works with Durable Objects, Workflows, and WorkerEntrypoints.\n */\nexport async function runInScope<T>(\n  callback: (container: Container) => T | Promise<T>\n): Promise<T> {\n  const app = await Stratal.resolveApplication()\n  const mockCtx = app.createMockRouterContext('en')\n  return app.container.runInRequestScope(mockCtx, callback)\n}\n","import { DurableObject } from 'cloudflare:workers'\nimport type { Container } from '../di/container'\nimport { DI_TOKENS } from '../di/tokens'\nimport type { StratalEnv } from '../env'\nimport { runInScope } from './run-in-scope'\n\n/**\n * Base class for Durable Objects with full DI access.\n *\n * Extends Cloudflare's `DurableObject` and provides a `runInScope()` helper\n * that creates a request-scoped container with `DurableObjectState` and\n * `DurableObjectId` tokens registered.\n *\n * @example\n * ```typescript\n * import { StratalDurableObject } from 'stratal/workers'\n *\n * export class Counter extends StratalDurableObject {\n *   async increment() {\n *     return this.runInScope(async (container) => {\n *       const svc = container.resolve(CounterService)\n *       return svc.increment()\n *     })\n *   }\n * }\n * ```\n */\nexport abstract class StratalDurableObject<\n  Env extends StratalEnv = StratalEnv\n> extends DurableObject<Env> {\n  protected async runInScope<T>(\n    callback: (container: Container) => T | Promise<T>\n  ): Promise<T> {\n    return runInScope(async (requestContainer) => {\n      requestContainer.registerValue(DI_TOKENS.DurableObjectState, this.ctx)\n      requestContainer.registerValue(DI_TOKENS.DurableObjectId, this.ctx.id)\n      return callback(requestContainer)\n    })\n  }\n}\n","import { WorkerEntrypoint } from 'cloudflare:workers'\nimport type { Container } from '../di/container'\nimport type { StratalEnv } from '../env'\nimport { runInScope } from './run-in-scope'\n\n/**\n * Base class for Cloudflare WorkerEntrypoints (Service Bindings / RPC) with full DI access.\n *\n * Extends Cloudflare's `WorkerEntrypoint` and provides a `runInScope()` helper\n * that creates a request-scoped DI container.\n *\n * @example\n * ```typescript\n * import { StratalWorkerEntrypoint } from 'stratal/workers'\n *\n * export class AuthRpc extends StratalWorkerEntrypoint {\n *   async verifyToken(token: string) {\n *     return this.runInScope(async (container) => {\n *       const auth = container.resolve(AuthService)\n *       return auth.verify(token)\n *     })\n *   }\n * }\n * ```\n */\nexport abstract class StratalWorkerEntrypoint<\n  Env extends StratalEnv = StratalEnv\n> extends WorkerEntrypoint<Env> {\n  protected runInScope<T>(\n    callback: (container: Container) => T | Promise<T>\n  ): Promise<T> {\n    return runInScope(callback)\n  }\n}\n","import { WorkflowEntrypoint } from 'cloudflare:workers'\nimport type { Container } from '../di/container'\nimport type { StratalEnv } from '../env'\nimport { runInScope } from './run-in-scope'\n\n/**\n * Base class for Cloudflare Workflows with full DI access.\n *\n * Extends Cloudflare's `WorkflowEntrypoint` and provides a `runInScope()` helper\n * that creates a request-scoped DI container.\n *\n * @example\n * ```typescript\n * import { StratalWorkflow } from 'stratal/workers'\n *\n * export class MyWorkflow extends StratalWorkflow<Env, { userId: string }> {\n *   async run(event: WorkflowEvent<{ userId: string }>, step: WorkflowStep) {\n *     await this.runInScope(async (container) => {\n *       const svc = container.resolve(UserService)\n *       await svc.process(event.payload.userId)\n *     })\n *   }\n * }\n * ```\n */\nexport abstract class StratalWorkflow<\n  Env extends StratalEnv = StratalEnv,\n  Params = unknown\n> extends WorkflowEntrypoint<Env, Params> {\n  protected runInScope<T>(\n    callback: (container: Container) => T | Promise<T>\n  ): Promise<T> {\n    return runInScope(callback)\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;AASA,eAAsB,WACpB,UACY;CACZ,MAAM,MAAM,MAAM,QAAQ,oBAAoB;CAC9C,MAAM,UAAU,IAAI,wBAAwB,KAAK;AACjD,QAAO,IAAI,UAAU,kBAAkB,SAAS,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;ACa3D,IAAsB,uBAAtB,cAEU,cAAmB;CAC3B,MAAgB,WACd,UACY;AACZ,SAAO,WAAW,OAAO,qBAAqB;AAC5C,oBAAiB,cAAc,UAAU,oBAAoB,KAAK,IAAI;AACtE,oBAAiB,cAAc,UAAU,iBAAiB,KAAK,IAAI,GAAG;AACtE,UAAO,SAAS,iBAAiB;IACjC;;;;;;;;;;;;;;;;;;;;;;;;;ACZN,IAAsB,0BAAtB,cAEU,iBAAsB;CAC9B,WACE,UACY;AACZ,SAAO,WAAW,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;ACN/B,IAAsB,kBAAtB,cAGU,mBAAgC;CACxC,WACE,UACY;AACZ,SAAO,WAAW,SAAS"}