@hadoku/worker-utils 0.0.0-stage → 1.6.19

package/dist/index.js

@@ -0,0 +1,976 @@
+// auth.ts
+function getAuthContext(c, contextKey = "authContext") {
+  return c.get(contextKey);
+}
+var TIER_RANK = {
+  public: 0,
+  member: 1,
+  friend: 2,
+  service: 3,
+  wife: 4,
+  admin: 5
+};
+function tierAtLeast(auth, minTier) {
+  if (!Object.hasOwn(TIER_RANK, minTier)) {
+    throw new Error(`tierAtLeast: unknown required tier '${minTier}'`);
+  }
+  const caller = auth?.userType;
+  const callerRank = caller !== void 0 && Object.hasOwn(TIER_RANK, caller) ? TIER_RANK[caller] : 0;
+  return callerRank >= TIER_RANK[minTier];
+}
+function requireMinTier(minTier, options = {}) {
+  const {
+    contextKey = "authContext",
+    errorMessage = "Insufficient permissions",
+    errorStatus = 403
+  } = options;
+  return async (c, next) => {
+    if (!tierAtLeast(getAuthContext(c, contextKey), minTier)) {
+      return c.json({ error: errorMessage }, errorStatus);
+    }
+    await next();
+  };
+}
+
+// content-level.ts
+var DEFAULT_CONTENT_LEVEL = 1;
+var MAX_CONTENT_LEVEL_BY_TIER = {
+  admin: 4,
+  wife: 3,
+  service: 3,
+  friend: 3,
+  member: 3
+};
+function maxContentLevelForTier(tier) {
+  if (!tier || TIER_RANK[tier] === void 0) return DEFAULT_CONTENT_LEVEL;
+  return MAX_CONTENT_LEVEL_BY_TIER[tier] ?? DEFAULT_CONTENT_LEVEL;
+}
+
+// edgeAuth.ts
+var TIERS = new Set(Object.keys(TIER_RANK));
+function timingSafeEqual(a, b) {
+  if (a.length !== b.length) return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++) {
+    diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  }
+  return diff === 0;
+}
+var EDGE_IDENTITY_HEADERS = [
+  "X-User-Id",
+  "X-User-Name",
+  "X-Hadoku-Tier",
+  "X-Hadoku-Content-Level"
+];
+function withoutEdgeIdentity(req) {
+  const headers = new Headers(req.headers);
+  for (const h of EDGE_IDENTITY_HEADERS) headers.delete(h);
+  return new Request(req, { headers });
+}
+var headerOrNull = (c, name) => {
+  const v = c.req.header(name)?.trim();
+  return v ? v : null;
+};
+function verifyEdgeAuth(c, env) {
+  const secret = env.EDGE_AUTH_SECRET;
+  if (!secret) return { ok: false, reason: "misconfigured" };
+  const provided = c.req.header("X-Edge-Auth") ?? "";
+  if (!timingSafeEqual(provided, secret)) {
+    return { ok: false, reason: "bad-provenance" };
+  }
+  const rawTier = c.req.header("X-Hadoku-Tier") ?? "public";
+  const userType = TIERS.has(rawTier) ? rawTier : "public";
+  const credential = c.req.header("X-User-Key") ?? null;
+  return {
+    ok: true,
+    userType,
+    credential,
+    userId: headerOrNull(c, "X-User-Id"),
+    userName: headerOrNull(c, "X-User-Name")
+  };
+}
+function createEdgeAuth(options) {
+  const contextKey = options?.contextKey ?? "authContext";
+  return async (c, next) => {
+    const result = verifyEdgeAuth(c, c.env);
+    if (!result.ok) c.req.raw = withoutEdgeIdentity(c.req.raw);
+    const base = result.ok ? {
+      userType: result.userType,
+      credential: result.credential,
+      userId: result.userId,
+      userName: result.userName
+    } : { userType: "public", credential: null, userId: null, userName: null };
+    const ctx = options?.extend ? { ...base, ...options.extend(base) } : base;
+    c.set(contextKey, ctx);
+    await next();
+  };
+}
+
+// context.ts
+function extractField(c, sources, defaultValue, transform) {
+  for (const source of sources) {
+    const [type, key] = source.split(":");
+    let value;
+    switch (type.toLowerCase()) {
+      case "header":
+        value = c.req.header(key);
+        break;
+      case "query":
+        value = c.req.query(key);
+        break;
+      case "body":
+        value = void 0;
+        break;
+      case "param":
+        value = c.req.param(key);
+        break;
+      case "cookie": {
+        const cookieHeader = c.req.header("Cookie");
+        if (cookieHeader) {
+          const cookies = Object.fromEntries(
+            cookieHeader.split(";").map((cookie) => {
+              const [k, v] = cookie.trim().split("=");
+              return [k, v];
+            })
+          );
+          value = cookies[key];
+        }
+        break;
+      }
+      default:
+        continue;
+    }
+    if (value !== void 0 && value !== null && value !== "") {
+      return transform ? transform(value) : value;
+    }
+  }
+  return defaultValue;
+}
+function extractContext(c, config) {
+  const result = {};
+  for (const [fieldName, sources] of Object.entries(config.fields)) {
+    const defaultValue = config.defaults?.[fieldName];
+    const transform = config.transforms?.[fieldName];
+    result[fieldName] = extractField(c, sources, defaultValue, transform);
+  }
+  return result;
+}
+async function parseBody(c, fallback = {}) {
+  try {
+    return await c.req.json();
+  } catch {
+    return fallback;
+  }
+}
+function getRequestMetadata(c) {
+  const cf = c.req.raw.cf;
+  return {
+    ip: c.req.header("CF-Connecting-IP") || c.req.header("X-Forwarded-For"),
+    userAgent: c.req.header("User-Agent"),
+    country: cf?.country,
+    city: cf?.city,
+    region: cf?.region,
+    timezone: cf?.timezone,
+    colo: cf?.colo,
+    requestId: c.req.header("CF-Ray") || crypto.randomUUID()
+  };
+}
+
+// validation.ts
+function validateField(value, rule) {
+  if (rule.required && (value === void 0 || value === null || value === "")) {
+    return `${rule.field} is required`;
+  }
+  if (value === void 0 || value === null) {
+    return null;
+  }
+  if (rule.type) {
+    const actualType = Array.isArray(value) ? "array" : typeof value;
+    if (actualType !== rule.type) {
+      return `${rule.field} must be of type ${rule.type}`;
+    }
+  }
+  if (typeof value === "string") {
+    if (rule.minLength !== void 0 && value.length < rule.minLength) {
+      return `${rule.field} must be at least ${rule.minLength} characters`;
+    }
+    if (rule.maxLength !== void 0 && value.length > rule.maxLength) {
+      return `${rule.field} must be at most ${rule.maxLength} characters`;
+    }
+    if (rule.pattern && !rule.pattern.test(value)) {
+      return `${rule.field} format is invalid`;
+    }
+  }
+  if (rule.custom) {
+    const result = rule.custom(value);
+    if (result !== true && typeof result === "string") {
+      return result;
+    }
+    if (result === false) {
+      return `${rule.field} is invalid`;
+    }
+  }
+  return null;
+}
+function validateFields(data, rules) {
+  const errors = [];
+  for (const rule of rules) {
+    const value = data[rule.field];
+    const error = validateField(value, rule);
+    if (error) {
+      errors.push({ field: rule.field, message: error });
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+function requireFields(data, fields) {
+  for (const field of fields) {
+    const value = data[field];
+    if (value === void 0 || value === null || typeof value === "string" && value.trim() === "") {
+      return `Missing required field: ${field}`;
+    }
+  }
+  return null;
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim() !== "";
+}
+var CommonRules = {
+  /**
+   * ID field (required, non-empty string)
+   */
+  id: () => ({
+    field: "id",
+    required: true,
+    type: "string",
+    custom: (val) => typeof val === "string" && val.trim() !== "" || "ID cannot be empty"
+  }),
+  /**
+   * Title field (required, 1-500 characters)
+   */
+  title: (options = {}) => ({
+    field: "title",
+    required: true,
+    type: "string",
+    minLength: options.minLength ?? 1,
+    maxLength: options.maxLength ?? 500,
+    custom: (val) => typeof val === "string" && val.trim() !== "" || "Title cannot be empty"
+  }),
+  /**
+   * Email field
+   */
+  email: (required = false) => ({
+    field: "email",
+    required,
+    type: "string",
+    pattern: /^[\w-.]+@([\w-]+\.)+[\w-]{2,4}$/
+  }),
+  /**
+   * URL field
+   */
+  url: (required = false) => ({
+    field: "url",
+    required,
+    type: "string",
+    pattern: /^https?:\/\/(www\.)?[-a-zA-Z0-9@:%._+~#=]{1,256}\.[a-zA-Z0-9()]{1,6}\b([-a-zA-Z0-9()@:%_+.~#?&//=]*)$/
+  }),
+  /**
+   * Enum field (value must be in allowed list)
+   */
+  enum: (field, allowedValues, required = false) => ({
+    field,
+    required,
+    custom: (val) => allowedValues.includes(val) || `${field} must be one of: ${allowedValues.join(", ")}`
+  }),
+  /**
+   * Array field with optional element validation
+   */
+  array: (field, options = {}) => ({
+    field,
+    required: options.required,
+    type: "array",
+    custom: (val) => {
+      if (!Array.isArray(val)) return false;
+      if (options.minLength !== void 0 && val.length < options.minLength) {
+        return `${field} must have at least ${options.minLength} items`;
+      }
+      if (options.maxLength !== void 0 && val.length > options.maxLength) {
+        return `${field} must have at most ${options.maxLength} items`;
+      }
+      if (options.elementType) {
+        const invalidItem = val.find((item) => {
+          const actualType = Array.isArray(item) ? "array" : typeof item;
+          return actualType !== options.elementType;
+        });
+        if (invalidItem !== void 0) {
+          return `All ${field} items must be of type ${options.elementType}`;
+        }
+      }
+      return true;
+    }
+  }),
+  /**
+   * Number field with optional range validation
+   */
+  number: (field, options = {}) => ({
+    field,
+    required: options.required,
+    type: "number",
+    custom: (val) => {
+      if (typeof val !== "number") return false;
+      if (options.integer && !Number.isInteger(val)) {
+        return `${field} must be an integer`;
+      }
+      if (options.min !== void 0 && val < options.min) {
+        return `${field} must be at least ${options.min}`;
+      }
+      if (options.max !== void 0 && val > options.max) {
+        return `${field} must be at most ${options.max}`;
+      }
+      return true;
+    }
+  }),
+  /**
+   * Boolean field
+   */
+  boolean: (field, required = false) => ({
+    field,
+    required,
+    type: "boolean"
+  })
+};
+
+// cors.ts
+import { cors } from "hono/cors";
+
+// edge-routes.ts
+var EDGE_BASE = "https://hadoku.me";
+var MGMT_BASE = `${EDGE_BASE}/mgmt`;
+var MONITORING_BASE = `${EDGE_BASE}/health`;
+var SCRAPER_BASE = `${EDGE_BASE}/scraper`;
+var CONTACT_BASE = `${EDGE_BASE}/contact`;
+var RESUME_BASE = `${EDGE_BASE}/resume`;
+var DISPATCH_BASE = `${EDGE_BASE}/dispatch`;
+var PREFS_BASE = `${EDGE_BASE}/prefs`;
+var JOBPLATFORM_BASE = `${EDGE_BASE}/jobplatform`;
+
+// cors.ts
+var DEFAULT_HADOKU_ORIGINS = [
+  EDGE_BASE,
+  "https://task-api.hadoku.me",
+  "http://localhost:*"
+];
+function matchOrigin(origin, pattern) {
+  if (origin === pattern) return true;
+  if (pattern.includes("*")) {
+    const regexPattern = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+    const regex = new RegExp(`^${regexPattern}$`);
+    return regex.test(origin);
+  }
+  return false;
+}
+function isOriginAllowed(origin, allowedOrigins) {
+  return allowedOrigins.some((pattern) => matchOrigin(origin, pattern));
+}
+function createCorsMiddleware(config) {
+  const {
+    origins,
+    methods = ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"],
+    allowedHeaders,
+    exposedHeaders,
+    credentials = true,
+    maxAge = 86400
+  } = config;
+  return cors({
+    origin: (origin) => {
+      if (!origin) return origins[0];
+      return isOriginAllowed(origin, origins) ? origin : origins[0];
+    },
+    allowMethods: methods,
+    allowHeaders: allowedHeaders,
+    exposeHeaders: exposedHeaders,
+    credentials,
+    maxAge
+  });
+}
+function createHadokuCors(additionalOrigins = []) {
+  return createCorsMiddleware({
+    origins: [...DEFAULT_HADOKU_ORIGINS, ...additionalOrigins],
+    credentials: true
+  });
+}
+var CORSPresets = {
+  /**
+   * Development - Allow all localhost origins
+   */
+  development: {
+    origins: ["http://localhost:*", "http://127.0.0.1:*"],
+    credentials: true
+  },
+  /**
+   * Production - Strict origin checking
+   */
+  production: (domains) => ({
+    origins: domains,
+    credentials: true,
+    maxAge: 86400
+  }),
+  /**
+   * Public API - Allow all origins (no credentials)
+   */
+  publicApi: {
+    origins: ["*"],
+    credentials: false
+  },
+  /**
+   * Hadoku standard - Production + development origins
+   */
+  hadoku: {
+    origins: DEFAULT_HADOKU_ORIGINS,
+    credentials: true,
+    maxAge: 86400
+  }
+};
+function getCorsHeaders(origin, allowedOrigins, options = {}) {
+  const headers = {};
+  if (origin && isOriginAllowed(origin, allowedOrigins)) {
+    headers["Access-Control-Allow-Origin"] = origin;
+    if (options.credentials !== false) {
+      headers["Access-Control-Allow-Credentials"] = "true";
+    }
+    if (options.exposedHeaders && options.exposedHeaders.length > 0) {
+      headers["Access-Control-Expose-Headers"] = options.exposedHeaders.join(", ");
+    }
+  }
+  return headers;
+}
+
+// cloudflareWorkerLogger.ts
+import { createWorkerLogger } from "@wolffm/logger/worker";
+function deriveService(prefix) {
+  if (!prefix) return "worker";
+  const trimmed = prefix.trim();
+  if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
+    return trimmed.slice(1, -1);
+  }
+  return trimmed;
+}
+function createLogger(config = {}) {
+  return createWorkerLogger({
+    service: deriveService(config.prefix),
+    minLevel: config.minLevel ?? "info"
+  });
+}
+var defaultLogger = createWorkerLogger({ service: "worker" });
+function logRequest(method, path, context, level = "info") {
+  defaultLogger[level](`[${method} ${path}]`, context);
+}
+function logError(method, path, error, context) {
+  const message = error instanceof Error ? error.message : error;
+  const ctx = { ...context ?? {} };
+  if (error instanceof Error && error.stack) ctx.stack = error.stack;
+  defaultLogger.error(`[${method} ${path}] ${message}`, ctx);
+}
+function createRequestLogger(method, path, baseContext = {}) {
+  const scoped = defaultLogger.child(`${method} ${path}`);
+  const merge = (extra) => ({ ...baseContext, ...extra ?? {} });
+  return {
+    debug: (message, context) => scoped.debug(message, merge(context)),
+    info: (message, context) => scoped.info(message, merge(context)),
+    warn: (message, context) => scoped.warn(message, merge(context)),
+    error: (message, context) => scoped.error(message, merge(context))
+  };
+}
+function loggerMiddleware(config = {}, contextKey = "logger") {
+  return async (c, next) => {
+    const logger = createLogger(config);
+    c.set(contextKey, logger);
+    await next();
+  };
+}
+function formatError(error) {
+  if (error instanceof Error) {
+    return { name: error.name, message: error.message, stack: error.stack };
+  }
+  return { error: String(error) };
+}
+function startTimer() {
+  const start = Date.now();
+  return {
+    end: (message, context) => {
+      const duration = Date.now() - start;
+      defaultLogger.info(`${message} (duration: ${duration}ms)`, context);
+      return duration;
+    },
+    elapsed: () => Date.now() - start
+  };
+}
+function redactFields(obj, fields) {
+  const redacted = { ...obj };
+  for (const field of fields) {
+    if (field in redacted) redacted[field] = "[REDACTED]";
+  }
+  return redacted;
+}
+var SENSITIVE_FIELDS = [
+  "password",
+  "apiKey",
+  "api_key",
+  "token",
+  "accessToken",
+  "access_token",
+  "refreshToken",
+  "refresh_token",
+  "secret",
+  "privateKey",
+  "private_key",
+  "authorization",
+  "cookie",
+  "session"
+];
+
+// rate-limit.ts
+async function checkRateLimit(kv, identifier, config) {
+  const prefix = config.keyPrefix ?? "rate-limit";
+  const key = `${prefix}:${identifier}`;
+  const windowMs = config.windowSeconds * 1e3;
+  const now = Date.now();
+  const existingData = await kv.get(key, "text");
+  const existing = existingData ? JSON.parse(existingData) : null;
+  if (!existing || now - existing.windowStart >= windowMs) {
+    return {
+      allowed: true,
+      remaining: config.maxRequests - 1,
+      resetAt: now + windowMs
+    };
+  }
+  if (existing.count >= config.maxRequests) {
+    const resetAt = existing.windowStart + windowMs;
+    const timeRemaining = resetAt - now;
+    const display = timeRemaining >= 12e4 ? `${Math.ceil(timeRemaining / 6e4)} minute(s)` : `${Math.ceil(timeRemaining / 1e3)} second(s)`;
+    return {
+      allowed: false,
+      remaining: 0,
+      resetAt,
+      reason: `Rate limit exceeded. Try again in ${display}.`
+    };
+  }
+  return {
+    allowed: true,
+    remaining: config.maxRequests - existing.count - 1,
+    resetAt: existing.windowStart + windowMs
+  };
+}
+async function recordRequest(kv, identifier, config) {
+  const prefix = config.keyPrefix ?? "rate-limit";
+  const key = `${prefix}:${identifier}`;
+  const windowMs = config.windowSeconds * 1e3;
+  const now = Date.now();
+  const existingData = await kv.get(key, "text");
+  const existing = existingData ? JSON.parse(existingData) : null;
+  let entry;
+  if (!existing || now - existing.windowStart >= windowMs) {
+    entry = { count: 1, windowStart: now };
+  } else {
+    entry = { count: existing.count + 1, windowStart: existing.windowStart };
+  }
+  await kv.put(key, JSON.stringify(entry), {
+    expirationTtl: config.kvTtlSeconds
+  });
+}
+async function resetRateLimit(kv, identifier, config) {
+  const prefix = config?.keyPrefix ?? "rate-limit";
+  const key = `${prefix}:${identifier}`;
+  await kv.delete(key);
+}
+
+// masking.ts
+var MASKING = {
+  /** Percentage of key to show (default: 50%) */
+  KEY_PERCENTAGE: 0.5,
+  /** Minimum characters to show for keys */
+  KEY_MIN_LENGTH: 4,
+  /** Number of characters to show for session IDs (default: 16) */
+  SESSION_ID_PREFIX_LENGTH: 16
+};
+function maskKey(key, percentage = MASKING.KEY_PERCENTAGE) {
+  if (!key) {
+    return key;
+  }
+  const showLength = Math.max(MASKING.KEY_MIN_LENGTH, Math.floor(key.length * percentage));
+  if (key.length <= showLength) {
+    return key;
+  }
+  return key.substring(0, showLength);
+}
+function maskSessionId(id) {
+  if (!id) {
+    return id;
+  }
+  const length = MASKING.SESSION_ID_PREFIX_LENGTH;
+  if (id.length <= length) {
+    return id;
+  }
+  return id.substring(0, length);
+}
+function maskIpAddress(ip) {
+  if (!ip) {
+    return void 0;
+  }
+  if (ip.includes(".")) {
+    const parts = ip.split(".");
+    if (parts.length === 4) {
+      return `${parts[0]}.${parts[1]}.${parts[2]}.*`;
+    }
+  }
+  if (ip.includes(":")) {
+    const lastColon = ip.lastIndexOf(":");
+    if (lastColon > 0) {
+      return ip.substring(0, lastColon + 1) + "*";
+    }
+  }
+  return ip;
+}
+function maskEmail(email) {
+  if (!email?.includes("@")) {
+    return email;
+  }
+  const [username, domain] = email.split("@");
+  if (!username || !domain) {
+    return email;
+  }
+  return `${username[0]}***@${domain}`;
+}
+
+// responses.ts
+function ok(c, data, message) {
+  const response = {
+    data,
+    ...message && { message },
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  return c.json(response, 200);
+}
+function created(c, data, message) {
+  const response = {
+    data,
+    message: message || "Resource created successfully",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  return c.json(response, 201);
+}
+function badRequest(c, error, details) {
+  const response = {
+    error,
+    ...details !== void 0 ? { details } : {},
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  return c.json(response, 400);
+}
+function notFound(c, resource = "Resource") {
+  const response = {
+    error: `${resource} not found`,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  return c.json(response, 404);
+}
+function serverError(c, message = "Internal server error", details) {
+  const response = {
+    error: message,
+    ...details !== void 0 ? { details } : {},
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  return c.json(response, 500);
+}
+function validationError(c, errors, message = "Validation failed") {
+  const response = {
+    error: message,
+    details: { errors },
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  return c.json(response, 400);
+}
+function healthCheck(c, serviceName, checks, options = {}) {
+  let status = options.status || "ok";
+  if (checks && !options.status) {
+    const hasFailures = Object.values(checks).some((v) => v === false);
+    const allFailed = Object.values(checks).every((v) => v === false);
+    if (allFailed) {
+      status = "error";
+    } else if (hasFailures) {
+      status = "degraded";
+    }
+  }
+  const response = {
+    status,
+    service: serviceName,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    ...options.version && { version: options.version },
+    ...checks && { checks },
+    ...options.remediation && { remediation: options.remediation },
+    ...options.gauges && { gauges: options.gauges }
+  };
+  const statusCode = status === "ok" ? 200 : 503;
+  return c.json(response, statusCode);
+}
+
+// openapi-schemas.ts
+import { z } from "@hono/zod-openapi";
+var HEALTH_STATUS_VALUES = ["ok", "degraded", "error"];
+var ErrorResponseSchema = z.object({
+  success: z.literal(false),
+  error: z.string().openapi({ example: "Bad Request" })
+}).openapi("ErrorResponse");
+var SimpleErrorResponseSchema = z.object({
+  error: z.string().openapi({ example: "Bad Request" }),
+  message: z.string().optional().openapi({ example: "Missing required field: title" })
+}).openapi("SimpleErrorResponse");
+var DetailedErrorResponseSchema = z.object({
+  success: z.literal(false),
+  error: z.string().openapi({ example: "Validation Error" }),
+  message: z.string().openapi({ example: "Invalid input data" })
+}).openapi("DetailedErrorResponse");
+var ThrottleErrorResponseSchema = z.object({
+  error: z.literal("Rate limit exceeded"),
+  message: z.string().openapi({ example: "Too many requests" }),
+  retryAfter: z.number().openapi({ example: 60 })
+}).openapi("ThrottleErrorResponse");
+function createHealthResponseSchema(serviceName, options) {
+  const baseSchema = z.object({
+    status: z.enum(HEALTH_STATUS_VALUES).openapi({ example: "ok" }),
+    timestamp: z.string().openapi({ example: "2024-01-15T10:30:00.000Z" }),
+    service: z.literal(serviceName)
+  });
+  if (options?.includeChecks) {
+    return baseSchema.extend({
+      checks: z.object({
+        kv: z.boolean().openapi({ example: true })
+      })
+    }).openapi(`${serviceName}HealthResponse`);
+  }
+  return baseSchema.openapi(`${serviceName}HealthResponse`);
+}
+function createWrappedHealthResponseSchema(serviceName) {
+  return z.object({
+    success: z.literal(true),
+    data: z.object({
+      status: z.literal("healthy"),
+      service: z.literal(serviceName),
+      timestamp: z.string().openapi({ example: "2024-01-15T10:30:00.000Z" })
+    })
+  }).openapi(`${serviceName}HealthResponse`);
+}
+function createSuccessResponseSchema(dataSchema) {
+  return z.object({
+    success: z.literal(true),
+    data: dataSchema
+  });
+}
+function createDeleteResponseSchema(idField = "id", example = "01HXYZ123ABC") {
+  return z.object({
+    deleted: z.literal(true),
+    [idField]: z.string().openapi({ example })
+  }).openapi("DeleteResponse");
+}
+var ValidationErrorResponseSchema = z.object({
+  error: z.literal("Validation Error"),
+  message: z.string().openapi({ example: "id: Required, title: String must contain at least 1 character(s)" })
+}).openapi("ValidationErrorResponse");
+var TaskApiHealthResponseSchema = createHealthResponseSchema("task-api-adapter", {
+  includeChecks: true
+});
+var PromptApiHealthResponseSchema = createHealthResponseSchema("prompt-api");
+
+// openapi-config.ts
+function createValidationHook(format = "simple") {
+  return (result, c) => {
+    if (!result.success) {
+      const issues = result.error.issues;
+      const message = issues.map((i) => `${i.path.join(".")}: ${i.message}`).join(", ");
+      if (format === "wrapped") {
+        return c.json(
+          {
+            success: false,
+            error: "Validation Error",
+            message
+          },
+          400
+        );
+      }
+      return c.json(
+        {
+          error: "Validation Error",
+          message
+        },
+        400
+      );
+    }
+  };
+}
+var simpleValidationHook = createValidationHook("simple");
+var wrappedValidationHook = createValidationHook("wrapped");
+function createErrorHandlers(format = "simple") {
+  const notFoundHandler = (c) => {
+    if (format === "wrapped") {
+      return c.json(
+        {
+          success: false,
+          error: "Not found",
+          message: "The requested endpoint does not exist"
+        },
+        404
+      );
+    }
+    return c.json(
+      {
+        error: "Not found",
+        message: "The requested endpoint does not exist"
+      },
+      404
+    );
+  };
+  const errorHandler = (err, c) => {
+    console.error("Unhandled error:", err);
+    if (format === "wrapped") {
+      return c.json(
+        {
+          success: false,
+          error: "Internal server error",
+          message: "An unexpected error occurred"
+        },
+        500
+      );
+    }
+    return c.json(
+      {
+        error: "Internal server error",
+        message: "An unexpected error occurred"
+      },
+      500
+    );
+  };
+  return { notFoundHandler, errorHandler };
+}
+function createOpenAPIDocConfig(options) {
+  const { title, version, description, production, localPort = 8787, tags = [] } = options;
+  return {
+    openapi: "3.0.0",
+    info: {
+      title,
+      version,
+      description: description.trim()
+    },
+    servers: [
+      {
+        url: production,
+        description: "Production"
+      },
+      {
+        url: `http://localhost:${localPort}`,
+        description: "Local development"
+      }
+    ],
+    tags
+  };
+}
+var CommonTags = {
+  Health: { name: "Health", description: "Health check endpoints" },
+  Admin: { name: "Admin", description: "Admin operations (requires authentication)" }
+};
+function okWrapped(c, data) {
+  return c.json({ success: true, data }, 200);
+}
+function createdWrapped(c, data) {
+  return c.json({ success: true, data }, 201);
+}
+function badRequestWrapped(c, message) {
+  return c.json({ success: false, error: "Bad Request", message }, 400);
+}
+function notFoundWrapped(c, resource = "Resource") {
+  return c.json(
+    {
+      success: false,
+      error: "Not Found",
+      message: `${resource} not found`
+    },
+    404
+  );
+}
+function serverErrorWrapped(c, message = "Internal server error") {
+  return c.json({ success: false, error: "Internal Server Error", message }, 500);
+}
+export {
+  CORSPresets,
+  CommonRules,
+  CommonTags,
+  DEFAULT_CONTENT_LEVEL,
+  DEFAULT_HADOKU_ORIGINS,
+  DetailedErrorResponseSchema,
+  ErrorResponseSchema,
+  MASKING,
+  MAX_CONTENT_LEVEL_BY_TIER,
+  PromptApiHealthResponseSchema,
+  SENSITIVE_FIELDS,
+  SimpleErrorResponseSchema,
+  TIER_RANK,
+  TaskApiHealthResponseSchema,
+  ThrottleErrorResponseSchema,
+  ValidationErrorResponseSchema,
+  badRequest,
+  badRequestWrapped,
+  checkRateLimit,
+  createCorsMiddleware,
+  createDeleteResponseSchema,
+  createEdgeAuth,
+  createErrorHandlers,
+  createHadokuCors,
+  createHealthResponseSchema,
+  createLogger,
+  createOpenAPIDocConfig,
+  createRequestLogger,
+  createSuccessResponseSchema,
+  createValidationHook,
+  createWrappedHealthResponseSchema,
+  created,
+  createdWrapped,
+  extractContext,
+  extractField,
+  formatError,
+  getAuthContext,
+  getCorsHeaders,
+  getRequestMetadata,
+  healthCheck,
+  isNonEmptyString,
+  isOriginAllowed,
+  logError,
+  logRequest,
+  loggerMiddleware,
+  maskEmail,
+  maskIpAddress,
+  maskKey,
+  maskSessionId,
+  matchOrigin,
+  maxContentLevelForTier,
+  notFound,
+  notFoundWrapped,
+  ok,
+  okWrapped,
+  parseBody,
+  recordRequest,
+  redactFields,
+  requireFields,
+  requireMinTier,
+  resetRateLimit,
+  serverError,
+  serverErrorWrapped,
+  simpleValidationHook,
+  startTimer,
+  tierAtLeast,
+  validateFields,
+  validationError,
+  verifyEdgeAuth,
+  wrappedValidationHook
+};