@voyant-travel/hono 0.128.0 → 0.128.2

package/dist/app.js

@@ -19,7 +19,6 @@ import { cors } from "./middleware/cors.js";
 import { db } from "./middleware/db.js";
 import { handleApiError, requestId } from "./middleware/error-boundary.js";
 import { logger } from "./middleware/logger.js";
-import { metrics } from "./middleware/metrics.js";
 import { publicResponseCache } from "./middleware/public-cache.js";
 import { rateLimit, resolveRateLimitStore, } from "./middleware/rate-limit.js";
 import { requireActor } from "./middleware/require-actor.js";
@@ -372,11 +371,6 @@ export function mountApp(config) {
     app.use("*", requestId);
     // Structured logger
     app.use("*", logger(config.logger));
-    // Per-request metrics → Analytics Engine (no-op without the binding).
-    // Mounted before the cache middleware so cache hits are measured too.
-    if (config.metrics !== false) {
-        app.use("*", metrics());
-    }
     // CORS (allowlist via env CORS_ALLOWLIST)
     app.use("*", cors());
     if (config.securityHeaders !== false) {

package/dist/index.d.ts

@@ -20,5 +20,5 @@ export { stampOpenApiRegistryApiId } from "./openapi-ownership.js";
 export { openApiValidationHook } from "./openapi-validation.js";
 export type { CreatePublicCapabilityOptions, PublicCapabilityCookieOptions, PublicCapabilityPayload, VerifyPublicCapabilityOptions, } from "./public-capability.js";
 export { createPublicCapabilityToken, extractPublicCapabilityToken, serializePublicCapabilityCookie, verifyPublicCapabilityToken, } from "./public-capability.js";
-export type { DbFactory, DbFactorySelector, DbSource, DbSurfaceSelection, LogEntry, LoggerProvider, VoyantAppConfig, VoyantAuthIntegration, VoyantAuthPermissionArgs, VoyantAuthResolveArgs, VoyantBindings, VoyantDb, VoyantExecutionContext, VoyantQueryRuntime, VoyantRequestAuthContext, VoyantRouteHandler, VoyantVariables, } from "./types.js";
+export type { DbFactory, DbFactorySelector, DbSource, DbSurfaceSelection, LogEntry, LoggerProvider, VoyantAppConfig, VoyantAuthAppTokenResolveArgs, VoyantAuthIntegration, VoyantAuthPermissionArgs, VoyantAuthResolveArgs, VoyantBindings, VoyantDb, VoyantExecutionContext, VoyantQueryRuntime, VoyantRequestAuthContext, VoyantRouteHandler, VoyantVariables, } from "./types.js";
 export { ApiHttpError, ForbiddenApiError, normalizeValidationError, parseJsonBody, parseOptionalJsonBody, parseQuery, RequestValidationError, UnauthorizedApiError, } from "./validation.js";

package/dist/middleware/auth.js

@@ -139,6 +139,19 @@ function applyAuthContext(c, auth) {
         c.set("apiTokenId", auth.apiTokenId);
     if (auth.apiKeyId)
         c.set("apiKeyId", auth.apiKeyId);
+    if (auth.appId)
+        c.set("appId", auth.appId);
+    if (auth.appInstallationId)
+        c.set("appInstallationId", auth.appInstallationId);
+    if (auth.appReleaseId)
+        c.set("appReleaseId", auth.appReleaseId);
+    if (auth.appCredentialGeneration !== undefined) {
+        c.set("appCredentialGeneration", auth.appCredentialGeneration);
+    }
+    if (auth.appTokenMode)
+        c.set("appTokenMode", auth.appTokenMode);
+    if (auth.appViewerId)
+        c.set("appViewerId", auth.appViewerId);
 }
 export function requireAuth(dbSource, opts) {
     const publicPaths = opts?.publicPaths ?? [];
@@ -270,7 +283,29 @@ export function requireAuth(dbSource, opts) {
                 await lease.release();
             }
         }
-        // Strategy 3: App-provided auth resolution (cookies, provider tokens, etc.)
+        // Strategy 3: Remote app access token support
+        if (token && opts?.auth?.resolveAppToken) {
+            const lease = acquireRequestDb(c, dbFactory);
+            try {
+                const resolved = await opts.auth.resolveAppToken({
+                    request: c.req.raw,
+                    env: c.env,
+                    db: lease.db,
+                    // Guarded: Hono throws on `executionCtx` access outside Workers.
+                    ctx: tryGetExecutionCtx(c),
+                    token,
+                });
+                if (resolved?.callerType === "app" && resolved.appInstallationId) {
+                    applyAuthContext(c, resolved);
+                    // `await` is load-bearing — see strategy 2.
+                    return await next();
+                }
+            }
+            finally {
+                await lease.release();
+            }
+        }
+        // Strategy 4: App-provided auth resolution (cookies, provider tokens, etc.)
         if (opts?.auth?.resolve) {
             const lease = acquireRequestDb(c, dbFactory);
             try {
@@ -293,7 +328,7 @@ export function requireAuth(dbSource, opts) {
                 await lease.release();
             }
         }
-        // Strategy 4: Generic session-claims bearer token support
+        // Strategy 5: Generic session-claims bearer token support
         const sessionSecret = c.env.SESSION_CLAIMS_SECRET;
         if (token && sessionSecret && token.includes(".")) {
             try {

package/dist/middleware/index.d.ts

@@ -5,9 +5,8 @@ export { db } from "./db.js";
 export { errorBoundary, type HandleApiErrorOptions, handleApiError, requestId, } from "./error-boundary.js";
 export { DEFAULT_IDEMPOTENCY_TTL_MS, type IdempotencyKeyOptions, idempotencyKey, purgeExpiredIdempotencyKeys, } from "./idempotency-key.js";
 export { consoleLoggerProvider, logger } from "./logger.js";
-export { type AnalyticsEngineDatasetLike, DB_METRICS_CONTEXT_KEY, type MetricsMiddlewareOptions, metrics, type RequestDbMetrics, withQueryCounting, } from "./metrics.js";
 export { type PublicCacheOptions, publicResponseCache, resetPublicCacheStateForTests, } from "./public-cache.js";
-export { type CloudflareRateLimiterBinding, clientIpKey, createCloudflareRateLimitStore, createKvRateLimitStore, createMemoryRateLimitStore, createRedisRateLimitStore, enforceRateLimit, LIVE_LIMITS, type RateLimitConfig, type RateLimitPolicy, type RateLimitRequestContext, type RateLimitResult, type RateLimitRule, type RateLimitStore, type RedisRateLimitStoreOptions, rateLimit, resolveRateLimitStore, } from "./rate-limit.js";
+export { clientIpKey, createMemoryRateLimitStore, createRedisRateLimitStore, enforceRateLimit, LIVE_LIMITS, type RateLimitConfig, type RateLimitPolicy, type RateLimitRequestContext, type RateLimitResult, type RateLimitRule, type RateLimitStore, type RedisRateLimitStoreOptions, rateLimit, resolveRateLimitStore, } from "./rate-limit.js";
 export { isStaffRbacEnforced, requireActor } from "./require-actor.js";
 export { requirePermission } from "./require-permission.js";
 export { type SecurityHeadersOptions, securityHeaders } from "./security-headers.js";

package/dist/middleware/index.js

@@ -5,9 +5,8 @@ export { db } from "./db.js";
 export { errorBoundary, handleApiError, requestId, } from "./error-boundary.js";
 export { DEFAULT_IDEMPOTENCY_TTL_MS, idempotencyKey, purgeExpiredIdempotencyKeys, } from "./idempotency-key.js";
 export { consoleLoggerProvider, logger } from "./logger.js";
-export { DB_METRICS_CONTEXT_KEY, metrics, withQueryCounting, } from "./metrics.js";
 export { publicResponseCache, resetPublicCacheStateForTests, } from "./public-cache.js";
-export { clientIpKey, createCloudflareRateLimitStore, createKvRateLimitStore, createMemoryRateLimitStore, createRedisRateLimitStore, enforceRateLimit, LIVE_LIMITS, rateLimit, resolveRateLimitStore, } from "./rate-limit.js";
+export { clientIpKey, createMemoryRateLimitStore, createRedisRateLimitStore, enforceRateLimit, LIVE_LIMITS, rateLimit, resolveRateLimitStore, } from "./rate-limit.js";
 export { isStaffRbacEnforced, requireActor } from "./require-actor.js";
 export { requirePermission } from "./require-permission.js";
 export { securityHeaders } from "./security-headers.js";

package/dist/middleware/metrics.d.ts

@@ -1,10 +1,5 @@
 import type { MiddlewareHandler } from "hono";
-import type { VoyantVariables } from "../types.js";
-/**
- * Structural shape of a Workers Analytics Engine dataset binding —
- * declared locally so `@voyant-travel/hono` needs no `@cloudflare/workers-types`
- * dependency.
- */
+/** Structural sink contract for request metrics. */
 export interface AnalyticsEngineDatasetLike {
     writeDataPoint(point: {
         blobs?: string[];
@@ -18,19 +13,11 @@ export interface RequestDbMetrics {
 }
 export declare const DB_METRICS_CONTEXT_KEY = "__voyantDbMetrics";
 export interface MetricsMiddlewareOptions {
-    /**
-     * Resolve the Analytics Engine dataset from bindings. Defaults to
-     * `env.METRICS`. Returning undefined makes the middleware a no-op for
-     * that request (deployments without the binding pay ~nothing).
-     */
-    dataset?: (env: unknown) => AnalyticsEngineDatasetLike | undefined;
+    /** Resolve the metrics sink for a request. Returning undefined is a no-op. */
+    dataset: (env: unknown) => AnalyticsEngineDatasetLike | undefined;
 }
 /**
- * Per-request metrics → Workers Analytics Engine (RFC voyant#1687 Phase
- * 3.4, the in-worker half — the platform dispatcher's DISPATCH_METRICS
- * dataset already records hostname/plan/cache/duration per dispatch;
- * this adds what only the worker can see: the matched route pattern,
- * the db query count, and in-worker cache hits).
+ * Per-request metrics for an explicitly supplied deployment sink.
  *
  * One data point per request:
  * - blobs:   [method, routePattern, surface, cacheStatus]
@@ -40,8 +27,10 @@ export interface MetricsMiddlewareOptions {
  * `writeDataPoint` is fire-and-forget and never throws into the
  * request; a missing binding short-circuits before timing overhead.
  */
-export declare function metrics(options?: MetricsMiddlewareOptions): MiddlewareHandler<{
-    Variables: Pick<VoyantVariables, typeof DB_METRICS_CONTEXT_KEY>;
+export declare function metrics(options: MetricsMiddlewareOptions): MiddlewareHandler<{
+    Variables: {
+        [DB_METRICS_CONTEXT_KEY]?: RequestDbMetrics;
+    };
 }>;
 /**
  * Wrap a drizzle client so top-level query-initiating calls increment

package/dist/middleware/metrics.js

@@ -9,11 +9,7 @@ function surfaceOf(path) {
     return "other";
 }
 /**
- * Per-request metrics → Workers Analytics Engine (RFC voyant#1687 Phase
- * 3.4, the in-worker half — the platform dispatcher's DISPATCH_METRICS
- * dataset already records hostname/plan/cache/duration per dispatch;
- * this adds what only the worker can see: the matched route pattern,
- * the db query count, and in-worker cache hits).
+ * Per-request metrics for an explicitly supplied deployment sink.
  *
  * One data point per request:
  * - blobs:   [method, routePattern, surface, cacheStatus]
@@ -23,9 +19,8 @@ function surfaceOf(path) {
  * `writeDataPoint` is fire-and-forget and never throws into the
  * request; a missing binding short-circuits before timing overhead.
  */
-export function metrics(options = {}) {
-    const resolveDataset = options.dataset ??
-        ((env) => env?.METRICS);
+export function metrics(options) {
+    const resolveDataset = options.dataset;
     return async (c, next) => {
         const dataset = resolveDataset(c.env);
         if (!dataset || typeof dataset.writeDataPoint !== "function") {

package/dist/middleware/rate-limit.d.ts

@@ -1,4 +1,3 @@
-import type { KVStore } from "@voyant-travel/utils/cache";
 import { type LazyRedisClient } from "@voyant-travel/utils/redis-client";
 import type { MiddlewareHandler } from "hono";
 /**
@@ -6,11 +5,9 @@ import type { MiddlewareHandler } from "hono";
  *
  * The limiter is split into two halves:
  *
- * - a {@link RateLimitStore} — the counting backend. Three implementations
- *   ship with the framework: the Cloudflare native Rate Limiting binding
- *   (truly distributed, limits configured in wrangler), a KV-backed
- *   fixed-window counter (best-effort — see {@link createKvRateLimitStore}),
- *   and an in-memory Map for Node/dev/tests (per-isolate).
+ * - a {@link RateLimitStore} — the counting backend. Composition injects the
+ *   selected provider; an in-memory Map remains the zero-configuration
+ *   fallback for Node/dev/tests.
  * - the enforcement surface — the {@link rateLimit} Hono middleware and the
  *   imperative {@link enforceRateLimit} helper that route packages
  *   (storefront, bookings, …) call directly inside handlers.
@@ -73,9 +70,8 @@ export interface RateLimitPolicy {
 export interface RateLimitConfig {
     /**
      * Explicit store, or a function-of-bindings for stores built from env
-     * bindings (Workers env is only available per request). When omitted —
-     * or when the function returns `undefined` — resolution falls through
-     * to `c.env.RATE_LIMITER` (CF binding) → `c.env.RATE_LIMIT` (KV) →
+     * bindings. When omitted — or when the function returns `undefined` —
+     * resolution falls through to the injected `RATE_LIMIT_STORE`, then
      * in-memory.
      */
     store?: RateLimitStore | ((env: unknown) => RateLimitStore | undefined);
@@ -92,21 +88,6 @@ export interface RateLimitRule {
     max: number;
     windowSeconds: number;
 }
-/**
- * The Cloudflare native Rate Limiting binding shape (wrangler
- * `[[ratelimits]]`). The binding's `limit`/`period` are fixed in wrangler
- * config — the policy's `max`/`windowSeconds` are advisory for headers
- * only. One shared binding works across policies because the bucket is
- * part of the key; deployments wanting different limits per policy bind
- * one ratelimiter per policy and pass it via `policy.store`.
- */
-export interface CloudflareRateLimiterBinding {
-    limit(opts: {
-        key: string;
-    }): Promise<{
-        success: boolean;
-    }>;
-}
 /**
  * Minimal structural view of a Hono context — enough for key derivation,
  * store resolution, and response headers — so route packages can call
@@ -142,30 +123,6 @@ export declare function clientIpKey(c: {
 export declare function createMemoryRateLimitStore(options?: {
     maxEntries?: number;
 }): RateLimitStore;
-/**
- * KV-backed fixed-window store.
- *
- * **Best-effort by construction**: KV is eventually consistent and the
- * counter is a non-atomic read-modify-write, so concurrent requests
- * across PoPs undercount — a determined attacker gets somewhat more than
- * `max` through before the window converges. With per-client keys this
- * is still a real brake on brute force and write floods; deployments
- * needing exact distributed limits should bind the Cloudflare Rate
- * Limiting binding (`RATE_LIMITER`) instead.
- *
- * Stored keys are `lim:<bucket>:<clientKey>:<windowKey>` (the window
- * suffix is appended here) with a TTL of `max(60, windowSeconds * 2)` —
- * KV's TTL floor is 60s.
- */
-export declare function createKvRateLimitStore(kv: KVStore): RateLimitStore;
-/**
- * Adapter for the Cloudflare native Rate Limiting binding. Truly
- * distributed and atomic; the actual limit/period are fixed in wrangler
- * config, so the policy's `max`/`windowSeconds` only inform the
- * `Retry-After` hint. `remaining` is never reported (the binding does
- * not expose it).
- */
-export declare function createCloudflareRateLimitStore(binding: CloudflareRateLimiterBinding): RateLimitStore;
 export interface RedisRateLimitStoreOptions {
     client?: LazyRedisClient;
 }
@@ -174,8 +131,8 @@ export declare function createRedisRateLimitStore(redisUrl: string, options?: Re
 export declare function resetRateLimitWarningsForTests(): void;
 /**
  * Resolve the best available store from the environment:
- * `c.env.RATE_LIMITER` (CF Rate Limiting binding) → `c.env.RATE_LIMIT`
- * (KV) → in-memory fallback. **Fails open into the memory store** —
+ * Injected `c.env.RATE_LIMIT_STORE` → in-memory fallback. **Fails open into
+ * the memory store** —
  * rate limiting must never break Node/headless deployments that bind
  * neither — but warns once per isolate outside dev/test so a
  * production deploy without a distributed backend is visible in logs.

package/dist/middleware/rate-limit.js

@@ -67,58 +67,6 @@ export function createMemoryRateLimitStore(options) {
         },
     };
 }
-/**
- * KV-backed fixed-window store.
- *
- * **Best-effort by construction**: KV is eventually consistent and the
- * counter is a non-atomic read-modify-write, so concurrent requests
- * across PoPs undercount — a determined attacker gets somewhat more than
- * `max` through before the window converges. With per-client keys this
- * is still a real brake on brute force and write floods; deployments
- * needing exact distributed limits should bind the Cloudflare Rate
- * Limiting binding (`RATE_LIMITER`) instead.
- *
- * Stored keys are `lim:<bucket>:<clientKey>:<windowKey>` (the window
- * suffix is appended here) with a TTL of `max(60, windowSeconds * 2)` —
- * KV's TTL floor is 60s.
- */
-export function createKvRateLimitStore(kv) {
-    return {
-        async limit(key, { max, windowSeconds }) {
-            const nowSeconds = Math.floor(Date.now() / 1000);
-            const windowKey = Math.floor(nowSeconds / windowSeconds);
-            const storageKey = `${key}:${windowKey}`;
-            const raw = await kv.get(storageKey);
-            const current = raw ? Number(raw) || 0 : 0;
-            const next = current + 1;
-            await kv.put(storageKey, String(next), {
-                expirationTtl: Math.max(60, windowSeconds * 2),
-            });
-            return {
-                allowed: next <= max,
-                remaining: Math.max(0, max - next),
-                retryAfterSeconds: Math.max(1, windowSeconds - (nowSeconds % windowSeconds)),
-            };
-        },
-    };
-}
-/**
- * Adapter for the Cloudflare native Rate Limiting binding. Truly
- * distributed and atomic; the actual limit/period are fixed in wrangler
- * config, so the policy's `max`/`windowSeconds` only inform the
- * `Retry-After` hint. `remaining` is never reported (the binding does
- * not expose it).
- */
-export function createCloudflareRateLimitStore(binding) {
-    return {
-        async limit(key, { windowSeconds }) {
-            const { success } = await binding.limit({ key });
-            return success
-                ? { allowed: true }
-                : { allowed: false, retryAfterSeconds: Math.max(1, windowSeconds) };
-        },
-    };
-}
 export function createRedisRateLimitStore(redisUrl, options = {}) {
     const lazyClient = options.client ?? createLazyRedisClient(redisUrl);
     return {
@@ -140,9 +88,7 @@ export function createRedisRateLimitStore(redisUrl, options = {}) {
     };
 }
 // ---- Store resolution ----
-const bindingStoreCache = new WeakMap();
 const explicitStoreCache = new WeakMap();
-const kvStoreCache = new WeakMap();
 const sharedMemoryStore = createMemoryRateLimitStore();
 let warnedNoDistributedStore = false;
 function isDevLikeEnv() {
@@ -156,23 +102,14 @@ export function resetRateLimitWarningsForTests() {
 }
 /**
  * Resolve the best available store from the environment:
- * `c.env.RATE_LIMITER` (CF Rate Limiting binding) → `c.env.RATE_LIMIT`
- * (KV) → in-memory fallback. **Fails open into the memory store** —
+ * Injected `c.env.RATE_LIMIT_STORE` → in-memory fallback. **Fails open into
+ * the memory store** —
  * rate limiting must never break Node/headless deployments that bind
  * neither — but warns once per isolate outside dev/test so a
  * production deploy without a distributed backend is visible in logs.
  */
 export function resolveRateLimitStore(c, memoryFallback = sharedMemoryStore) {
     const env = (c.env ?? {});
-    const binding = env.RATE_LIMITER;
-    if (binding && typeof binding.limit === "function") {
-        let store = bindingStoreCache.get(binding);
-        if (!store) {
-            store = createCloudflareRateLimitStore(binding);
-            bindingStoreCache.set(binding, store);
-        }
-        return store;
-    }
     const explicit = env.RATE_LIMIT_STORE;
     if (explicit && typeof explicit.limit === "function") {
         let store = explicitStoreCache.get(explicit);
@@ -182,19 +119,10 @@ export function resolveRateLimitStore(c, memoryFallback = sharedMemoryStore) {
         }
         return store;
     }
-    const kv = env.RATE_LIMIT;
-    if (kv && typeof kv.get === "function" && typeof kv.put === "function") {
-        let store = kvStoreCache.get(kv);
-        if (!store) {
-            store = createKvRateLimitStore(kv);
-            kvStoreCache.set(kv, store);
-        }
-        return store;
-    }
     if (!warnedNoDistributedStore && !isDevLikeEnv()) {
         warnedNoDistributedStore = true;
         console.warn("[voyant] rate-limit: no distributed store available (inject RATE_LIMIT_STORE " +
-            "or a KV-compatible RATE_LIMIT fallback). " +
+            "). " +
             "Falling back to a per-isolate in-memory limiter — limits apply " +
             "per instance, not fleet-wide.");
     }

package/dist/middleware/require-actor.js

@@ -98,7 +98,9 @@ export function requireActor(...args) {
     return async (c, next) => {
         if (c.req.method === "OPTIONS")
             return next();
-        if (c.get("callerType") === "api_key" || c.get("callerType") === "internal") {
+        if (c.get("callerType") === "api_key" ||
+            c.get("callerType") === "app" ||
+            c.get("callerType") === "internal") {
             const pathname = normalizePathname(new URL(c.req.url).pathname, {
                 basePath: options.basePath,
             });
@@ -116,7 +118,7 @@ export function requireActor(...args) {
                 hasAnyApiKeyPermission(c.get("scopes"), resource, actions, options.accessCatalog)) {
                 return next();
             }
-            return c.json({ error: "Forbidden: API key missing required permission" }, 403);
+            return c.json({ error: "Forbidden: token missing required permission" }, 403);
         }
         const actor = c.get("actor");
         if (!actor) {

package/dist/types.d.ts

@@ -24,17 +24,9 @@ export interface VoyantBindings {
     APP_URL?: string;
     DASH_BASE_URL?: string;
     API_BASE_URL?: string;
-    RATE_LIMIT?: KVStore;
     RATE_LIMIT_STORE?: import("./middleware/rate-limit.js").RateLimitStore;
     CACHE?: KVStore;
     SHARED_STATE?: KVStore;
-    RATE_LIMITER?: import("./middleware/rate-limit.js").CloudflareRateLimiterBinding;
-    /**
-     * Workers Analytics Engine dataset receiving per-request metrics
-     * (see the `metrics` middleware). Optional — without it the
-     * middleware is a no-op.
-     */
-    METRICS?: import("./middleware/metrics.js").AnalyticsEngineDatasetLike;
 }
 export type VoyantDb = PostgresJsDatabase | NeonHttpDatabase | NeonWsDatabase;
 export type VoyantQueryRuntime = QueryRunner;
@@ -55,8 +47,6 @@ export type VoyantVariables = CoreVoyantVariables & {
     query?: VoyantQueryRuntime;
     /** Optional workflow driver surfaced to HTTP routes after lazy app bootstrap. */
     workflowDriver?: import("@voyant-travel/workflows/driver").WorkflowDriver;
-    /** Per-request db metrics counter populated by the metrics middleware. */
-    __voyantDbMetrics?: import("./middleware/metrics.js").RequestDbMetrics;
 };
 /** Handler contract for application-authored Hono API routes. */
 export type VoyantRouteHandler<TBindings extends VoyantBindings = VoyantBindings> = Handler<{
@@ -144,6 +134,9 @@ export interface VoyantAuthResolveArgs<TBindings extends VoyantBindings = Voyant
     db: VoyantDb;
     ctx?: VoyantExecutionContext;
 }
+export interface VoyantAuthAppTokenResolveArgs<TBindings extends VoyantBindings = VoyantBindings> extends VoyantAuthResolveArgs<TBindings> {
+    token: string;
+}
 export interface VoyantAuthPermissionArgs<TBindings extends VoyantBindings = VoyantBindings> extends VoyantAuthResolveArgs<TBindings> {
     permission: VoyantPermission;
     auth: VoyantRequestAuthContext;
@@ -170,6 +163,7 @@ export interface VoyantAuthIntegration<TBindings extends VoyantBindings = Voyant
      * so `/v1/public/*` route guards work.
      */
     resolve?: (args: VoyantAuthResolveArgs<TBindings>) => Promise<VoyantRequestAuthContext | null> | VoyantRequestAuthContext | null;
+    resolveAppToken?: (args: VoyantAuthAppTokenResolveArgs<TBindings>) => Promise<VoyantAuthContext | null> | VoyantAuthContext | null;
     hasPermission?: (args: VoyantAuthPermissionArgs<TBindings>) => Promise<boolean> | boolean;
     validateApiKey?: (args: VoyantAuthApiKeyValidationArgs<TBindings>) => Promise<boolean> | boolean;
     onUnauthorized?: (args: VoyantAuthUnauthorizedArgs<TBindings>) => Promise<Response | null> | Response | null;
@@ -260,13 +254,6 @@ export interface VoyantAppConfig<TBindings extends VoyantBindings = VoyantBindin
      * `insertOutboxEvents(tx, ...)`. Default off.
      */
     outbox?: boolean;
-    /**
-     * Per-request metrics to the `env.METRICS` Analytics Engine dataset
-     * (method, route pattern, surface, cache status, duration, status,
-     * db query count). Enabled by default and inert without the binding;
-     * set `false` to disable entirely.
-     */
-    metrics?: boolean;
     /**
      * Default request body limit enforced before route handlers parse
      * JSON/form data. Content-type-aware: JSON bodies are capped at 10 MiB

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voyant-travel/hono",
-  "version": "0.128.0",
+  "version": "0.128.2",
   "license": "Apache-2.0",
   "type": "module",
   "exports": {
@@ -130,18 +130,17 @@
     "drizzle-orm": "^0.45.2",
     "hono": "^4.12.27",
     "zod": "^4.4.3",
-    "@voyant-travel/core": "^0.124.0",
-    "@voyant-travel/db": "^0.114.8",
-    "@voyant-travel/types": "^0.109.2",
+    "@voyant-travel/core": "^0.125.1",
+    "@voyant-travel/db": "^0.114.10",
+    "@voyant-travel/types": "^0.109.3",
     "@voyant-travel/utils": "^0.107.1",
-    "@voyant-travel/workflows": "^0.122.0"
+    "@voyant-travel/workflows": "^0.122.3"
   },
   "devDependencies": {
-    "@cloudflare/workers-types": "^4.20260702.1",
     "typescript": "^6.0.3",
     "vitest": "^4.1.9",
     "@voyant-travel/voyant-typescript-config": "^0.1.0",
-    "@voyant-travel/workflows-orchestrator": "^0.122.0"
+    "@voyant-travel/workflows-orchestrator": "^0.122.3"
   },
   "files": [
     "dist"