stratal 0.0.21 → 0.0.22

package/dist/validation.context-XTysWJ3b.mjs

@@ -0,0 +1,117 @@
+import { n as getContainer } from "./container-storage-GpNNz79X.mjs";
+import { t as I18N_TOKENS } from "./i18n.tokens-hwRpmjRq.mjs";
+//#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 && typeof issue.prefix === "string") params.startsWith = issue.prefix;
+		if ("suffix" in issue && typeof issue.suffix === "string") params.endsWith = issue.suffix;
+		if ("includes" in issue && typeof issue.includes === "string") params.includes = issue.includes;
+		if (issue.pattern) params.pattern = issue.pattern;
+		return params;
+	}
+	if (isTooSmall(issue)) {
+		params.minimum = Number(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 = Number(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() {
+	return (issue) => {
+		const messageKey = getMessageKey(issue);
+		const messageParams = getMessageParams(issue);
+		try {
+			return { message: getContainer().resolve(I18N_TOKENS.I18nService).t(messageKey, messageParams) };
+		} catch {
+			return { message: "Invalid input" };
+		}
+	};
+}
+//#endregion
+//#region src/i18n/validation/validation.context.ts
+/**
+* Zod error map that resolves I18nService from the DI container.
+* Falls back to 'Invalid input' when called outside the container scope
+* (e.g., config validation at startup, tests).
+*/
+const zodErrorMap = createI18nErrorMap();
+//#endregion
+export { zodErrorMap as t };
+
+//# sourceMappingURL=validation.context-XTysWJ3b.mjs.map

package/dist/validation.context-XTysWJ3b.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.context-XTysWJ3b.mjs","names":[],"sources":["../src/i18n/validation/validation.error-map.ts","../src/i18n/validation/validation.context.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 { getContainer } from '../../di/container-storage'\nimport { I18N_TOKENS } from '../i18n.tokens'\nimport type { II18nService, MessageKeys } from '../i18n.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, string | number> {\n  const params: Record<string, string | number> = {}\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 && typeof issue.prefix === 'string') {\n      params.startsWith = issue.prefix\n    }\n    if ('suffix' in issue && typeof issue.suffix === 'string') {\n      params.endsWith = issue.suffix\n    }\n    if ('includes' in issue && typeof issue.includes === 'string') {\n      params.includes = issue.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 = Number(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 = Number(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(): $ZodErrorMap {\n  return (issue: $ZodRawIssue): { message: string } => {\n    const messageKey = getMessageKey(issue)\n    const messageParams = getMessageParams(issue)\n\n    try {\n      const container = getContainer()\n      const i18n = container.resolve<II18nService>(I18N_TOKENS.I18nService)\n      return { message: i18n.t(messageKey, messageParams) }\n    } catch {\n      return { message: 'Invalid input' }\n    }\n  }\n}\n","import { createI18nErrorMap } from './validation.error-map'\n\n/**\n * Zod error map that resolves I18nService from the DI container.\n * Falls back to 'Invalid input' when called outside the container scope\n * (e.g., config validation at startup, tests).\n */\nexport const zodErrorMap = createI18nErrorMap()\n"],"mappings":";;;;;;AAmBA,SAAS,cAAc,OAAkE;CACvF,OAAO,MAAM,SAAS;;AAGxB,SAAS,SAAS,OAA6D;CAC7E,OAAO,MAAM,SAAS;;AAGxB,SAAS,WAAW,OAA+D;CACjF,OAAO,MAAM,SAAS;;AAGxB,SAAS,gBAAgB,OAA0E;CACjG,OAAO,MAAM,SAAS;;AAGxB,SAAS,gBAAgB,OAAoE;CAC3F,OAAO,MAAM,SAAS;;AAGxB,SAAS,mBAAmB,OAAuE;CACjG,OAAO,MAAM,SAAS;;AAGxB,SAAS,eAAe,OAAmE;CACzF,OAAO,MAAM,SAAS;;AAGxB,SAAS,aAAa,OAAiE;CACrF,OAAO,MAAM,SAAS;;;;;;AAOxB,SAAS,cAAc,OAAkC;CACvD,IAAI,cAAc,MAAM,EAAE;EACxB,IAAI,MAAM,UAAU,KAAA,GAClB,OAAO;EAET,OAAO;;CAGT,IAAI,WAAW,MAAM,EAOnB,OAAO,4BANS,MAAM,UAAU,SAMW,GAL1B,MAAM,QACnB,UACA,MAAM,YACJ,cACA;CAIR,IAAI,SAAS,MAAM,EAOjB,OAAO,0BANS,MAAM,UAAU,SAMS,GALxB,MAAM,QACnB,UACA,MAAM,YACJ,cACA;CAIR,IAAI,gBAAgB,MAAM,EAExB,OAAO,iCAAiC,MAAM;CAGhD,IAAI,gBAAgB,MAAM,EACxB,OAAO;CAGT,IAAI,mBAAmB,MAAM,EAC3B,OAAO;CAGT,IAAI,eAAe,MAAM,EACvB,OAAO;CAGT,IAAI,aAAa,MAAM,EAErB,OAAO;CAIT,OAAO;;;;;;AAOT,SAAS,iBAAiB,OAAsD;CAC9E,MAAM,SAA0C,EAAE;CAElD,IAAI,cAAc,MAAM,EAAE;EACxB,OAAO,WAAW,MAAM;EACxB,OAAO,WAAW,OAAO,MAAM,MAAM;EACrC,OAAO;;CAGT,IAAI,mBAAmB,MAAM,EAAE;EAC7B,OAAO,OAAO,MAAM,KAAK,KAAK,KAAK;EACnC,OAAO;;CAGT,IAAI,aAAa,MAAM,EAGrB,OAAO;CAGT,IAAI,gBAAgB,MAAM,EAAE;EAC1B,OAAO,aAAa,MAAM;EAG1B,IAAI,YAAY,SAAS,OAAO,MAAM,WAAW,UAC/C,OAAO,aAAa,MAAM;EAE5B,IAAI,YAAY,SAAS,OAAO,MAAM,WAAW,UAC/C,OAAO,WAAW,MAAM;EAE1B,IAAI,cAAc,SAAS,OAAO,MAAM,aAAa,UACnD,OAAO,WAAW,MAAM;EAE1B,IAAI,MAAM,SACR,OAAO,UAAU,MAAM;EAGzB,OAAO;;CAGT,IAAI,WAAW,MAAM,EAAE;EACrB,OAAO,UAAU,OAAO,MAAM,QAAQ;EACtC,OAAO,OAAO,MAAM;EACpB,IAAI,MAAM,WAAW,QACnB,OAAO,UAAU,IAAI,KAAK,OAAO,MAAM,QAAQ,CAAC,CAAC,oBAAoB;EAEvE,OAAO;;CAGT,IAAI,SAAS,MAAM,EAAE;EACnB,OAAO,UAAU,OAAO,MAAM,QAAQ;EACtC,OAAO,OAAO,MAAM;EACpB,IAAI,MAAM,WAAW,QACnB,OAAO,UAAU,IAAI,KAAK,OAAO,MAAM,QAAQ,CAAC,CAAC,oBAAoB;EAEvE,OAAO;;CAGT,IAAI,gBAAgB,MAAM,EAAE;EAC1B,OAAO,aAAa,MAAM;EAC1B,OAAO;;CAGT,OAAO;;;;;;AAOT,SAAgB,qBAAmC;CACjD,QAAQ,UAA6C;EACnD,MAAM,aAAa,cAAc,MAAM;EACvC,MAAM,gBAAgB,iBAAiB,MAAM;EAE7C,IAAI;GAGF,OAAO,EAAE,SAFS,cACI,CAAC,QAAsB,YAAY,YACnC,CAAC,EAAE,YAAY,cAAc,EAAE;UAC/C;GACN,OAAO,EAAE,SAAS,iBAAiB;;;;;;;;;;;AC1LzC,MAAa,cAAc,oBAAoB"}

package/dist/websocket/index.d.mts

@@ -1,5 +1,5 @@
-import { B as ContextQueryResult, Bn as ControllerOptions, V as RouterContext, Xn as RouterEnv, d as ApplicationError } from "../index-ByOyTmqf.mjs";
-import { t as Constructor } from "../types-cySNS_lp.mjs";
+import { Wn as ControllerOptions, er as RouterEnv, nt as ContextQueryResult, rt as RouterContext, xr as ApplicationError } from "../index-DEncMcC6.mjs";
+import { t as Constructor } from "../types-BaeHi67f.mjs";
 import { Context } from "hono";
 import { WSContext, WSContext as WSContext$1, WSEvents, WSMessageReceive, WSReadyState, WSReadyState as WSReadyState$1 } from "hono/ws";
 
@@ -107,16 +107,6 @@ declare function getWsOnCloseMethod(target: Constructor): string | undefined;
  */
 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
@@ -164,10 +154,13 @@ declare class GatewayContext extends RouterContext {
   /**
    * Request body is not available in WebSocket gateways
    *
-   * @throws WebSocketBodyNotAvailableError always — WebSocket upgrade requests do not have a body
+   * @throws WebSocketError 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 };
+//#region src/websocket/websocket.error.d.ts
+declare class WebSocketError extends ApplicationError {}
+//#endregion
+export { Gateway, GatewayContext, type GatewayOptions, OnClose, OnError, OnMessage, type WSContext, type WSEvents, type WSMessageReceive, type WSReadyState, WebSocketError, getWsOnCloseMethod, getWsOnErrorMethod, getWsOnMessageMethod, isGateway };
 //# sourceMappingURL=index.d.mts.map

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

@@ -1 +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;;;;;;;;AC6BA;;;;;;;;;;;;;;;;iBAAgB,OAAA,CAAQ,KAAA,UAAe,OAAA,GAAU,cAAA,cACpB,WAAA,EAAa,MAAA,EAAQ,CAAA,KAAC,CAAA;;;AAanD;;;;iBAAgB,SAAA,CAAU,MAAA;;;;;;;;AD3C1B;;;;;;;;AC6BA;iBCDgB,SAAA,CAAA,GAAa,eAAA;;;;;;;;;;;;;;;iBAsBb,OAAA,CAAA,GAAW,eAAA;;;ADP3B;;;;;;;;ACfA;;;;iBA0CgB,OAAA,CAAA,GAAW,eAAA;AApB3B;;;AAAA,iBA6BgB,oBAAA,CAAqB,MAAA,EAAQ,WAAA;;AAT7C;;iBAgBgB,kBAAA,CAAmB,MAAA,EAAQ,WAAA;;;AAP3C;iBAcgB,kBAAA,CAAmB,MAAA,EAAQ,WAAA;;;cCjG9B,8BAAA,SAAuC,gBAAA;EAAA,WAAA,CAAA;AAAA;;;cCAvC,mCAAA,SAA4C,gBAAA;cAC3C,SAAA,UAAmB,cAAA;AAAA;;;;AJGjC;;;;;;;;AC6BA;;;;;;;;cIXa,cAAA,SAAuB,aAAA;EAAA,SACiB,EAAA,EAAI,WAAA;cAA3C,CAAA,EAAG,OAAA,CAAQ,SAAA,GAA4B,EAAA,EAAI,WAAA;EJUlB;EILrC,IAAA,CAAK,IAAA,WAAe,WAAA,GAAc,UAAA,CAAW,WAAA;EJMlB;EID3B,KAAA,CAAM,IAAA,WAAe,MAAA;EJCmB;EAAA,IIIpC,UAAA,CAAA,GAAc,cAAA;EJJ+B;;AAanD;;;;;;;EIIW,KAAA,CAAA,GAAS,MAAA;EACT,KAAA,CAAM,GAAA;EHpBQ;;;;AAsBzB;EGSW,KAAA,WAAgB,MAAA,oFAAA,CAA2F,GAAA,GAAM,CAAA,GAAI,kBAAA,CAAmB,CAAA,EAAG,CAAA;;;;AHWtJ;;EGCW,IAAA,GAAA,CAAA,GAAW,OAAA,CAAQ,CAAA;AAAA"}
+{"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/gateway-context.ts","../../src/websocket/websocket.error.ts"],"mappings":";;;;;;;;;;KAMY,cAAA,GAAiB,IAAA,CAAK,iBAAA;;;;;;;AAAlC;;;;;;;;AC8BA;;;;;;;;;;;;;;;;iBAAgB,OAAA,CAAQ,KAAA,UAAe,OAAA,GAAU,cAAA,cACpB,WAAA,EAAa,MAAA,EAAQ,CAAA,KAAC,CAAA;;;AAanD;;;;iBAAgB,SAAA,CAAU,MAAA;;;;;;;;AD5C1B;;;;;;;;AC8BA;iBCDgB,SAAA,CAAA,GAAa,eAAA;;;;;;;;;;;;;;;iBAsBb,OAAA,CAAA,GAAW,eAAA;;;ADP3B;;;;;;;;ACfA;;;;iBA0CgB,OAAA,CAAA,GAAW,eAAA;AApB3B;;;AAAA,iBA6BgB,oBAAA,CAAqB,MAAA,EAAQ,WAAA;;AAT7C;;iBAgBgB,kBAAA,CAAmB,MAAA,EAAQ,WAAA;;;AAP3C;iBAcgB,kBAAA,CAAmB,MAAA,EAAQ,WAAA;;;;AF9F3C;;;;;;;;AC8BA;;;;;;;;cEZa,cAAA,SAAuB,aAAA;EAAA,SACiB,EAAA,EAAI,WAAA;cAA3C,CAAA,EAAG,OAAA,CAAQ,SAAA,GAA4B,EAAA,EAAI,WAAA;EFWlB;EENrC,IAAA,CAAK,IAAA,WAAe,WAAA,GAAc,UAAA,CAAW,WAAA;EFOlB;EEF3B,KAAA,CAAM,IAAA,WAAe,MAAA;EFEmB;EAAA,IEGpC,UAAA,CAAA,GAAc,cAAA;EFH+B;;AAanD;;;;;;;EEGW,KAAA,CAAA,GAAS,MAAA;EACT,KAAA,CAAM,GAAA;EDnBQ;;;;AAsBzB;ECQW,KAAA,WAAgB,MAAA,oFAAA,CAA2F,GAAA,GAAM,CAAA,GAAI,kBAAA,CAAmB,CAAA,EAAG,CAAA;;;;ADYtJ;;ECAW,IAAA,GAAA,CAAA,GAAW,OAAA,CAAQ,CAAA;AAAA;;;cC3EjB,cAAA,SAAuB,gBAAA"}

package/dist/websocket/index.mjs

@@ -1,2 +1,2 @@
-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-CXmXtaUP.mjs";
-export { Gateway, GatewayContext, OnClose, OnError, OnMessage, WebSocketBodyNotAvailableError, WebSocketDuplicateEventHandlerError, getWsOnCloseMethod, getWsOnErrorMethod, getWsOnMessageMethod, isGateway };
+import { a as getWsOnCloseMethod, c as WebSocketError, i as OnMessage, l as Gateway, n as OnClose, o as getWsOnErrorMethod, r as OnError, s as getWsOnMessageMethod, t as GatewayContext, u as isGateway } from "../gateway-context-CFe6a9gz.mjs";
+export { Gateway, GatewayContext, OnClose, OnError, OnMessage, WebSocketError, getWsOnCloseMethod, getWsOnErrorMethod, getWsOnMessageMethod, isGateway };

package/dist/workers/index.d.mts

@@ -1,5 +1,5 @@
-import { Dr as Container } from "../index-ByOyTmqf.mjs";
-import { t as StratalEnv } from "../env-D1rcZ8_r.mjs";
+import { Y as Container } from "../index-DEncMcC6.mjs";
+import { t as StratalEnv } from "../env-DKSbuBi5.mjs";
 import { DurableObject, WorkerEntrypoint, WorkflowEntrypoint } from "cloudflare:workers";
 
 //#region src/workers/run-in-scope.d.ts

package/dist/workers/index.mjs

@@ -1,5 +1,5 @@
-import { f as DI_TOKENS } from "../logger-DlV7NtvD.mjs";
-import { t as Stratal } from "../stratal-CNwpbSZl.mjs";
+import { c as DI_TOKENS } from "../di-BO1QIb5H.mjs";
+import { t as Stratal } from "../stratal-Bdq4IdB3.mjs";
 import { DurableObject, WorkerEntrypoint, WorkflowEntrypoint } from "cloudflare:workers";
 //#region src/workers/run-in-scope.ts
 /**
@@ -10,6 +10,7 @@ import { DurableObject, WorkerEntrypoint, WorkflowEntrypoint } from "cloudflare:
 */
 async function runInScope(callback) {
 	const app = await Stratal.resolveApplication();
+	await app.initializeHandlers();
 	const mockCtx = app.createMockRouterContext("en");
 	return app.container.runInRequestScope(mockCtx, callback);
 }

package/dist/workers/index.mjs.map

@@ -1 +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;CACjD,OAAO,IAAI,UAAU,kBAAkB,SAAS,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;ACa3D,IAAsB,uBAAtB,cAEU,cAAmB;CAC3B,MAAgB,WACd,UACY;EACZ,OAAO,WAAW,OAAO,qBAAqB;GAC5C,iBAAiB,cAAc,UAAU,oBAAoB,KAAK,IAAI;GACtE,iBAAiB,cAAc,UAAU,iBAAiB,KAAK,IAAI,GAAG;GACtE,OAAO,SAAS,iBAAiB;IACjC;;;;;;;;;;;;;;;;;;;;;;;;;ACZN,IAAsB,0BAAtB,cAEU,iBAAsB;CAC9B,WACE,UACY;EACZ,OAAO,WAAW,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;ACN/B,IAAsB,kBAAtB,cAGU,mBAAgC;CACxC,WACE,UACY;EACZ,OAAO,WAAW,SAAS"}
+{"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  await app.initializeHandlers()\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,IAAI,oBAAoB;CAC9B,MAAM,UAAU,IAAI,wBAAwB,KAAK;CACjD,OAAO,IAAI,UAAU,kBAAkB,SAAS,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;ACY3D,IAAsB,uBAAtB,cAEU,cAAmB;CAC3B,MAAgB,WACd,UACY;EACZ,OAAO,WAAW,OAAO,qBAAqB;GAC5C,iBAAiB,cAAc,UAAU,oBAAoB,KAAK,IAAI;GACtE,iBAAiB,cAAc,UAAU,iBAAiB,KAAK,IAAI,GAAG;GACtE,OAAO,SAAS,iBAAiB;IACjC;;;;;;;;;;;;;;;;;;;;;;;;;ACZN,IAAsB,0BAAtB,cAEU,iBAAsB;CAC9B,WACE,UACY;EACZ,OAAO,WAAW,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;ACN/B,IAAsB,kBAAtB,cAGU,mBAAgC;CACxC,WACE,UACY;EACZ,OAAO,WAAW,SAAS"}

package/dist/{index-Bnpfq6uk.d.mts → zod-DvWTfRpI.d.mts}

@@ -1,12 +1,60 @@
-import { t as index_d_exports$1 } from "./index-C1KvMncZ.mjs";
-import { AsyncLocalStorage } from "node:async_hooks";
+import { t as index_d_exports } from "./index-KMgSCSM7.mjs";
 import { OpenAPIHono, z, z as z$2 } from "@hono/zod-openapi";
-import * as _$zod from "zod";
 import { ZodError } from "zod";
 import { OpenAPIObject, PathItemObject } from "openapi3-ts/oas30";
-import * as _$zod_v4_core0 from "zod/v4/core";
 import { $ZodIssueCustom, $ZodRawIssue } from "zod/v4/core";
 
+//#region src/i18n/validation/cuid2.d.ts
+/**
+ * Default cuid2 shape: 24-32 lowercase-alphanumeric chars, starting with a
+ * letter. Matches what `@paralleldrive/cuid2` produces with default settings
+ * and what most apps expect when they say "cuid2".
+ *
+ * Used as the default for {@link cuid2}; exposed for callers who want to
+ * compose it into other patterns.
+ */
+declare const CUID2_REGEX: RegExp;
+/**
+ * Stratal's cuid2 validator — a stricter drop-in for Zod 4.3.6's `z.cuid2()`.
+ *
+ * **Why this exists.** Zod 4.3.6's built-in `z.cuid2()` uses the regex
+ * `/^[0-9a-z]+$/`, which accepts *any* non-empty lowercase-alphanumeric
+ * string (including 2-letter locale prefixes like `'sw'`). That makes it
+ * effectively useless as a tenant-id / external-id validator.
+ *
+ * This helper layers the proper shape regex on top of `z.cuid2()`, so:
+ * - validation actually enforces cuid2 shape;
+ * - the schema still carries `z.cuid2()`'s OpenAPI metadata (i.e. spec
+ *   output keeps `format: 'cuid2'`).
+ *
+ * @example
+ * ```ts
+ * import { z, withZodI18n } from 'stratal/validation'
+ * import { cuid2 } from 'stratal/validation'
+ *
+ * // Default 24-32 char cuid2:
+ * router.prefix('/:tenantId', z.object({ tenantId: cuid2() }))
+ *
+ * // Custom regex (e.g. fixed-length 24):
+ * router.prefix('/:tenantId', z.object({
+ *   tenantId: cuid2({ pattern: /^[a-z][0-9a-z]{23}$/ }),
+ * }))
+ *
+ * // Custom error message:
+ * cuid2(withZodI18n('tenants.errors.invalidId'))
+ *
+ * // Compose: chain anything Zod string accepts
+ * cuid2().describe('Tenant ID')
+ * ```
+ *
+ * @param options.pattern - Override the shape regex. Defaults to {@link CUID2_REGEX}.
+ * @param options.error - Custom error message (string or i18n key) for the regex check.
+ */
+declare function cuid2(options?: {
+  pattern?: RegExp;
+  error?: string | ((_issue: $ZodRawIssue) => string);
+}): z.ZodCUID2;
+//#endregion
 //#region src/i18n/i18n.types.d.ts
 /**
  * Recursively extract nested keys from an object type
@@ -24,7 +72,7 @@ type DeepKeys<T, Prefix extends string = ''> = T extends object ? { [K in keyof
  * System message keys - auto-derived from system en messages
  * These are messages used by packages/modules infrastructure
  */
-type SystemMessageKeys = DeepKeys<typeof index_d_exports$1>;
+type SystemMessageKeys = DeepKeys<typeof index_d_exports>;
 /**
  * Augmentable registry for app-specific message namespaces.
  *
@@ -119,104 +167,9 @@ interface II18nService {
   getLocale(): string;
 }
 //#endregion
-//#region src/i18n/validation/with-i18n.d.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'))
- * ```
- *
- * @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
- */
-declare function withI18n(key: MessageKeys, params?: Record<string, unknown>): {
-  error: (_issue: $ZodRawIssue) => string;
-};
-//#endregion
-//#region src/i18n/validation/cuid2.d.ts
-/**
- * Default cuid2 shape: 24-32 lowercase-alphanumeric chars, starting with a
- * letter. Matches what `@paralleldrive/cuid2` produces with default settings
- * and what most apps expect when they say "cuid2".
- *
- * Used as the default for {@link cuid2}; exposed for callers who want to
- * compose it into other patterns.
- */
-declare const CUID2_REGEX: RegExp;
-/**
- * Stratal's cuid2 validator — a stricter drop-in for Zod 4.3.6's `z.cuid2()`.
- *
- * **Why this exists.** Zod 4.3.6's built-in `z.cuid2()` uses the regex
- * `/^[0-9a-z]+$/`, which accepts *any* non-empty lowercase-alphanumeric
- * string (including 2-letter locale prefixes like `'sw'`). That makes it
- * effectively useless as a tenant-id / external-id validator.
- *
- * This helper layers the proper shape regex on top of `z.cuid2()`, so:
- * - validation actually enforces cuid2 shape;
- * - the schema still carries `z.cuid2()`'s OpenAPI metadata (i.e. spec
- *   output keeps `format: 'cuid2'`).
- *
- * @example
- * ```ts
- * import { z, withI18n } from 'stratal/validation'
- * import { cuid2 } from 'stratal/validation'
- *
- * // Default 24-32 char cuid2:
- * router.prefix('/:tenantId', z.object({ tenantId: cuid2() }))
- *
- * // Custom regex (e.g. fixed-length 24):
- * router.prefix('/:tenantId', z.object({
- *   tenantId: cuid2({ pattern: /^[a-z][0-9a-z]{23}$/ }),
- * }))
- *
- * // Custom error message:
- * cuid2(withI18n('tenants.errors.invalidId'))
- *
- * // Compose: chain anything Zod string accepts
- * cuid2().describe('Tenant ID')
- * ```
- *
- * @param options.pattern - Override the shape regex. Defaults to {@link CUID2_REGEX}.
- * @param options.error - Custom error message (string or i18n key) for the regex check.
- */
-declare function cuid2(options?: {
-  pattern?: RegExp;
-  error?: string | ((_issue: $ZodRawIssue) => string);
-}): z.ZodCUID2;
-//#endregion
 //#region src/i18n/validation/validation.types.d.ts
 /**
- * Context provided to error map for locale-aware translation
- */
-interface ErrorMapContext {
-  /**
-   * Translate a message key with optional parameters
-   */
-  t: (key: MessageKeys, params?: Record<string, unknown>) => string;
-  /**
-   * Current locale code (e.g., 'en', 'fr')
-   */
-  locale: string;
-}
-/**
- * Function that provides the current translation context
- * Used by error maps to access request-scoped or application-wide i18n
- */
-type LocaleProvider = () => ErrorMapContext | undefined;
-/**
- * Custom error metadata for withI18n helper
+ * Custom error metadata for withZodI18n helper
  */
 interface I18nErrorMetadata {
   /**
@@ -238,39 +191,11 @@ type ZodCustomIssue = $ZodIssueCustom & {
     [key: string]: unknown;
   };
 };
-//#endregion
-//#region src/i18n/validation/validation.context.d.ts
-/**
- * Backend error map that accesses I18nService from AsyncLocalStorage
- * Must be initialized in router middleware after locale detection
- */
-declare const backendErrorMap: _$zod.ZodErrorMap<_$zod_v4_core0.$ZodIssue>;
-/**
- * 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()
- *   )
- * })
- * ```
- */
-declare function runWithErrorMapContext<T>(context: ErrorMapContext, fn: () => T): T;
-declare namespace index_d_exports {
-  export { CUID2_REGEX, ErrorMapContext, I18nErrorMetadata, LocaleProvider, OpenAPIHono, OpenAPIObject, PathItemObject, ZodCustomIssue, ZodError, backendErrorMap, cuid2, runWithErrorMapContext, withI18n, z$2 as z };
+declare namespace zod_d_exports {
+  export { CUID2_REGEX, I18nErrorMetadata, OpenAPIHono, OpenAPIObject, PathItemObject, ZodCustomIssue, ZodError, cuid2, z$2 as z };
 }
 import * as import_zod from "zod";
 import * as import__hono_zod_openapi from "@hono/zod-openapi";
 //#endregion
-export { MessageParams as C, MessageKeys as S, SystemMessageKeys as T, AppMessageNamespaces as _, index_d_exports as a, II18nService as b, runWithErrorMapContext as c, LocaleProvider as d, ZodCustomIssue as f, AppMessageKeys as g, withI18n as h, ZodError as i, ErrorMapContext as l, cuid2 as m, OpenAPIObject as n, z$2 as o, CUID2_REGEX as p, PathItemObject as r, backendErrorMap as s, OpenAPIHono as t, I18nErrorMetadata as u, AppMessages as v, Prefixes as w, MessageKeyPrefix as x, DeepKeys as y };
-//# sourceMappingURL=index-Bnpfq6uk.d.mts.map
+export { Prefixes as _, z$2 as a, cuid2 as b, ZodCustomIssue as c, AppMessages as d, DeepKeys as f, MessageParams as g, MessageKeys as h, ZodError as i, AppMessageKeys as l, MessageKeyPrefix as m, OpenAPIObject as n, zod_d_exports as o, II18nService as p, PathItemObject as r, I18nErrorMetadata as s, OpenAPIHono as t, AppMessageNamespaces as u, SystemMessageKeys as v, CUID2_REGEX as y };
+//# sourceMappingURL=zod-DvWTfRpI.d.mts.map

package/dist/zod-DvWTfRpI.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zod-DvWTfRpI.d.mts","names":[],"sources":["../src/i18n/validation/cuid2.ts","../src/i18n/i18n.types.ts","../src/i18n/validation/validation.types.ts","../src/i18n/validation/zod.ts"],"mappings":";;;;;;;;;;;;;AAWA;;cAAa,WAAA,EAAW,MAAA;;;AAsCxB;;;;;;;;;;;;;;;;;;;;;AC7BA;;;;;;;;;;;;;iBD6BgB,KAAA,CAAM,OAAA;EAAY,OAAA,GAAU,MAAA;EAAQ,KAAA,cAAmB,MAAA,EAAQ,YAAA;AAAA,IAA0B,CAAA,CAAA,QAAA;;;;AAtCzG;;;;;AAsCA;;;;;KC7BY,QAAA,kCAA0C,CAAA,gCAEtC,CAAA,YAAa,CAAA,CAAE,CAAA,mBACzB,QAAA,CAAS,CAAA,CAAE,CAAA,MAAO,MAAA,GAAS,CAAA,UACxB,MAAA,GAAS,CAAA,WACR,CAAA;;;;;KAOE,iBAAA,GAAoB,QAAA,QAAgB,eAAA;;;;;;;;;AAZhD;;;;;;;;;;;;;;;;UAsCiB,oBAAA;;;;;KAML,WAAA,iBAA4B,oBAAA,GAAuB,oBAAA,CAAqB,CAAA;;;;;KAMxE,cAAA,GAAiB,QAAA,CAAS,WAAA;;;;;KAO1B,WAAA,GAAc,iBAAA,GAAoB,cAAA;;;;;AAnB9C;;;;;AAMA;;;;KA4BY,QAAA,qBAA6B,CAAA,yCACrC,IAAA,MAAU,IAAA,IAAQ,QAAA,CAAS,IAAA,MAC3B,CAAA;;;;;;;;;;AAxBJ;;;;;KAwCY,gBAAA,GAAmB,QAAA,CAAS,WAAA;;;;;KAM5B,aAAA,GAAgB,MAAA;;;;UAKX,YAAA;EA5BH;;;;;;;EAoCZ,CAAA,CAAE,GAAA,EAAK,WAAA,EAAa,MAAA,GAAS,aAAA;EArC6B;;;;;EA4C1D,SAAA;AAAA;;;;;;UClIe,iBAAA;;;AFKjB;EEDE,GAAA,EAAK,WAAA;;;;EAKL,MAAA,GAAS,MAAA;AAAA;;;;;KAOC,cAAA,GAAiB,eAAA;EAC3B,MAAA;IACE,IAAA,GAAO,iBAAA;IAAA,CACN,GAAA;EAAA;AAAA;AAAA"}

package/dist/zod-hMa3rSHV.mjs

@@ -0,0 +1,72 @@
+import { n as __reExport, t as __exportAll } from "./chunk-D1SwGrFN.mjs";
+import { OpenAPIHono, z, z as z$2 } from "@hono/zod-openapi";
+import { ZodError } from "zod";
+//#region src/i18n/validation/cuid2.ts
+/**
+* Default cuid2 shape: 24-32 lowercase-alphanumeric chars, starting with a
+* letter. Matches what `@paralleldrive/cuid2` produces with default settings
+* and what most apps expect when they say "cuid2".
+*
+* Used as the default for {@link cuid2}; exposed for callers who want to
+* compose it into other patterns.
+*/
+const CUID2_REGEX = /^[a-z][0-9a-z]{23,31}$/;
+/**
+* Stratal's cuid2 validator — a stricter drop-in for Zod 4.3.6's `z.cuid2()`.
+*
+* **Why this exists.** Zod 4.3.6's built-in `z.cuid2()` uses the regex
+* `/^[0-9a-z]+$/`, which accepts *any* non-empty lowercase-alphanumeric
+* string (including 2-letter locale prefixes like `'sw'`). That makes it
+* effectively useless as a tenant-id / external-id validator.
+*
+* This helper layers the proper shape regex on top of `z.cuid2()`, so:
+* - validation actually enforces cuid2 shape;
+* - the schema still carries `z.cuid2()`'s OpenAPI metadata (i.e. spec
+*   output keeps `format: 'cuid2'`).
+*
+* @example
+* ```ts
+* import { z, withZodI18n } from 'stratal/validation'
+* import { cuid2 } from 'stratal/validation'
+*
+* // Default 24-32 char cuid2:
+* router.prefix('/:tenantId', z.object({ tenantId: cuid2() }))
+*
+* // Custom regex (e.g. fixed-length 24):
+* router.prefix('/:tenantId', z.object({
+*   tenantId: cuid2({ pattern: /^[a-z][0-9a-z]{23}$/ }),
+* }))
+*
+* // Custom error message:
+* cuid2(withZodI18n('tenants.errors.invalidId'))
+*
+* // Compose: chain anything Zod string accepts
+* cuid2().describe('Tenant ID')
+* ```
+*
+* @param options.pattern - Override the shape regex. Defaults to {@link CUID2_REGEX}.
+* @param options.error - Custom error message (string or i18n key) for the regex check.
+*/
+function cuid2(options) {
+	const pattern = options?.pattern ?? CUID2_REGEX;
+	return z.cuid2({
+		pattern,
+		error: typeof options?.error === "string" ? options?.error : void 0,
+		...typeof options?.error === "function" ? { error: options?.error } : {}
+	});
+}
+//#endregion
+//#region src/i18n/validation/zod.ts
+var zod_exports = /* @__PURE__ */ __exportAll({
+	CUID2_REGEX: () => CUID2_REGEX,
+	OpenAPIHono: () => OpenAPIHono,
+	ZodError: () => ZodError,
+	cuid2: () => cuid2,
+	z: () => z$2
+});
+import * as import__hono_zod_openapi from "@hono/zod-openapi";
+__reExport(zod_exports, import__hono_zod_openapi);
+//#endregion
+export { CUID2_REGEX as a, zod_exports as i, ZodError as n, cuid2 as o, z$2 as r, OpenAPIHono as t };
+
+//# sourceMappingURL=zod-hMa3rSHV.mjs.map

package/dist/zod-hMa3rSHV.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"zod-hMa3rSHV.mjs","names":[],"sources":["../src/i18n/validation/cuid2.ts","../src/i18n/validation/zod.ts"],"sourcesContent":["import { z } from '@hono/zod-openapi';\nimport { type $ZodRawIssue } from 'zod/v4/core';\n\n/**\n * Default cuid2 shape: 24-32 lowercase-alphanumeric chars, starting with a\n * letter. Matches what `@paralleldrive/cuid2` produces with default settings\n * and what most apps expect when they say \"cuid2\".\n *\n * Used as the default for {@link cuid2}; exposed for callers who want to\n * compose it into other patterns.\n */\nexport const CUID2_REGEX = /^[a-z][0-9a-z]{23,31}$/\n\n/**\n * Stratal's cuid2 validator — a stricter drop-in for Zod 4.3.6's `z.cuid2()`.\n *\n * **Why this exists.** Zod 4.3.6's built-in `z.cuid2()` uses the regex\n * `/^[0-9a-z]+$/`, which accepts *any* non-empty lowercase-alphanumeric\n * string (including 2-letter locale prefixes like `'sw'`). That makes it\n * effectively useless as a tenant-id / external-id validator.\n *\n * This helper layers the proper shape regex on top of `z.cuid2()`, so:\n * - validation actually enforces cuid2 shape;\n * - the schema still carries `z.cuid2()`'s OpenAPI metadata (i.e. spec\n *   output keeps `format: 'cuid2'`).\n *\n * @example\n * ```ts\n * import { z, withZodI18n } from 'stratal/validation'\n * import { cuid2 } from 'stratal/validation'\n *\n * // Default 24-32 char cuid2:\n * router.prefix('/:tenantId', z.object({ tenantId: cuid2() }))\n *\n * // Custom regex (e.g. fixed-length 24):\n * router.prefix('/:tenantId', z.object({\n *   tenantId: cuid2({ pattern: /^[a-z][0-9a-z]{23}$/ }),\n * }))\n *\n * // Custom error message:\n * cuid2(withZodI18n('tenants.errors.invalidId'))\n *\n * // Compose: chain anything Zod string accepts\n * cuid2().describe('Tenant ID')\n * ```\n *\n * @param options.pattern - Override the shape regex. Defaults to {@link CUID2_REGEX}.\n * @param options.error - Custom error message (string or i18n key) for the regex check.\n */\nexport function cuid2(options?: { pattern?: RegExp; error?: string | ((_issue: $ZodRawIssue) => string) }) {\n  const pattern = options?.pattern ?? CUID2_REGEX\n  return z.cuid2({\n    pattern: pattern,\n    error: typeof options?.error === 'string' ? options?.error : undefined,\n    ...(typeof options?.error === 'function' ? { error: options?.error } : {})\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 { CUID2_REGEX, cuid2 } from './cuid2'\n\n// Types\nexport type { I18nErrorMetadata, ZodCustomIssue } from './validation.types'\n"],"mappings":";;;;;;;;;;;;AAWA,MAAa,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsC3B,SAAgB,MAAM,SAAqF;CACzG,MAAM,UAAU,SAAS,WAAW;CACpC,OAAO,EAAE,MAAM;EACJ;EACT,OAAO,OAAO,SAAS,UAAU,WAAW,SAAS,QAAQ,KAAA;EAC7D,GAAI,OAAO,SAAS,UAAU,aAAa,EAAE,OAAO,SAAS,OAAO,GAAG,EAAE;EAC1E,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stratal",
-  "version": "0.0.21",
+  "version": "0.0.22",
   "description": "A modular Cloudflare Workers framework with dependency injection, queue-based events, and type-safe configuration",
   "type": "module",
   "license": "MIT",
@@ -110,6 +110,10 @@
       "types": "./dist/quarry/index.d.mts",
       "import": "./dist/quarry/index.mjs"
     },
+    "./quarry/runner": {
+      "types": "./dist/quarry/runner.d.mts",
+      "import": "./dist/quarry/runner.mjs"
+    },
     "./queue": {
       "types": "./dist/queue/index.d.mts",
       "import": "./dist/queue/index.mjs"
@@ -155,25 +159,23 @@
     "bench:unit": "vitest bench --run --project unit",
     "bench:e2e": "vitest bench --run --project e2e",
     "bench:json": "vitest bench --run --outputJson benchmark-results.json",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "test:integration": "vitest run --project workerd",
-    "test:coverage": "vitest run --coverage",
+    "test": "NODE_OPTIONS='--expose-gc' vitest run",
+    "test:watch": "NODE_OPTIONS='--expose-gc' vitest",
+    "test:integration": "NODE_OPTIONS='--expose-gc' vitest run --project workerd",
+    "test:coverage": "NODE_OPTIONS='--expose-gc' vitest run --coverage",
     "lint": "npx oxlint .",
     "lint:fix": "npx oxlint --fix ."
   },
   "dependencies": {
     "@hono/swagger-ui": "^0.6.1",
     "@hono/zod-openapi": "^1.4.0",
-    "@intlify/core-base": "^11.4.2",
-    "@intlify/message-compiler": "^11.4.2",
     "@modelcontextprotocol/sdk": "^1.29.0",
     "@swc-node/register": "^1.11.1",
     "@swc/core": "^1.15.33",
     "@swc/helpers": "^0.5.21",
     "clipanion": "^4.0.0-rc.4",
     "hono": "^4.12.18",
-    "tsyringe": "^4.10.0",
+    "intl-messageformat": "^11.2.7",
     "zod": "^4.4.3"
   },
   "peerDependencies": {
@@ -181,7 +183,6 @@
     "nodemailer": ">=7",
     "react": ">=19",
     "react-dom": ">=19",
-    "reflect-metadata": ">=0.2",
     "resend": ">=6"
   },
   "peerDependenciesMeta": {
@@ -217,7 +218,6 @@
     "nodemailer": "^8.0.7",
     "react": "^19.2.6",
     "react-dom": "^19.2.6",
-    "reflect-metadata": "^0.2.2",
     "resend": "^6.12.3",
     "tsdown": "^0.22.0",
     "typescript": "^6.0.3",