@rdlabo/workers-hono-kit 0.10.4 → 0.10.6

package/dist/cache/kv-cache.js

@@ -121,14 +121,11 @@ export class KVCache {
         if (!key) {
             return undefined;
         }
-        let data;
-        try {
-            data = await this.#kv.get(key);
-        }
-        catch (error) {
+        const read = async () => this.#kv.get(key);
+        const data = await read().catch((error) => {
             this.#reportError(error, { operation: 'read', table });
-            return undefined;
-        }
+            return null;
+        });
         if (!data) {
             return undefined;
         }
@@ -179,7 +176,8 @@ export class KVCache {
             return;
         }
         const ttl = Math.max(this.#minTtl, lifetime ?? this.#defaultLifetime);
-        await this.#kv.put(key, payload, { expirationTtl: ttl }).catch((error) => {
+        const write = async () => this.#kv.put(key, payload, { expirationTtl: ttl });
+        await write().catch((error) => {
             this.#reportError(error, { operation: 'write', table });
         });
     }
@@ -243,7 +241,8 @@ export class KVCache {
         if (!key) {
             return;
         }
-        await this.#kv.delete(key).catch((error) => {
+        const remove = async () => this.#kv.delete(key);
+        await remove().catch((error) => {
             this.#reportError(error, { operation: 'delete', table });
         });
     }

package/dist/db/database.js

@@ -70,8 +70,8 @@ export function createHyperdriveDatabase(options) {
             return retryWhenDeadlock(() => dz.transaction(fn));
         },
         /** @deprecated Workers cleans up invocation-scoped connections automatically. */
-        dispose() {
-            return Promise.resolve();
+        async dispose() {
+            return;
         },
     };
 }

package/dist/db/retry.js

@@ -27,17 +27,17 @@
  */
 export async function retryWhenDeadlock(fn, retries = 3, delay = 100) {
     for (let attempt = 0; attempt < retries; attempt++) {
-        try {
-            return await fn();
+        const invoke = async () => fn();
+        const outcome = await invoke().then((value) => ({ ok: true, value }), (error) => ({ ok: false, error }));
+        if (outcome.ok) {
+            return outcome.value;
         }
-        catch (error) {
-            const code = error.code;
-            if (code === 'ER_LOCK_DEADLOCK' && attempt < retries - 1) {
-                await new Promise((resolve) => setTimeout(resolve, delay * (attempt + 1)));
-                continue;
-            }
-            throw error;
+        const code = outcome.error.code;
+        if (code === 'ER_LOCK_DEADLOCK' && attempt < retries - 1) {
+            await new Promise((resolve) => setTimeout(resolve, delay * (attempt + 1)));
+            continue;
         }
+        throw outcome.error;
     }
     // Unreachable: the loop returns on success and throws on the final failed attempt.
     throw new Error('retryWhenDeadlock: exhausted retries');

package/dist/middleware/auth.js

@@ -43,7 +43,7 @@ export function createAuthMiddleware(options) {
     return async (c, next) => {
         let stage = 'token';
         let tokenPresent = false;
-        try {
+        const authenticate = async () => {
             const token = c.req.header(tokenHeader) ?? '';
             tokenPresent = token.trim().length > 0;
             if (!tokenPresent && rejectMissingToken) {
@@ -57,24 +57,23 @@ export function createAuthMiddleware(options) {
             const userId = resolveUserId ? await resolveUserId(verified, c, appInfo) : undefined;
             stage = 'setContext';
             setContext(c, { verified, appInfo, userId });
-        }
-        catch (e) {
+        };
+        const outcome = await authenticate().then(() => ({ ok: true }), (error) => ({ ok: false, error }));
+        if (!outcome.ok) {
             const details = { stage, tokenPresent };
             if (reportFailure) {
-                try {
-                    await reportFailure(e, c, details);
-                }
-                catch (reportingError) {
+                const report = async () => reportFailure(outcome.error, c, details);
+                await report().catch((reportingError) => {
                     // Observability must never alter the authentication response.
                     console.error(reportingError);
-                }
+                });
             }
             else {
                 // Preserve the historical default for consumers that have not adopted classified reporting.
-                console.error(e);
+                console.error(outcome.error);
             }
             if (onFailure) {
-                return onFailure(e, c, details);
+                return onFailure(outcome.error, c, details);
             }
             throw new HTTPException(failureStatus, { message: failureMessage });
         }

package/dist/middleware/perf-log.js

@@ -98,12 +98,13 @@ export function perfLog(options = {}) {
         // In-code sampling thins Analytics Engine writes only; Workers Logs volume is controlled separately
         // by the observability `head_sampling_rate`. Low-traffic Workers should leave `sampleRate` at 1.
         if (sink && (rate >= 1 || Math.random() < rate)) {
+            const point = {
+                doubles: [tApp, cold ? 1 : 0, status],
+                blobs: [path, colo, method],
+                indexes: [analyticsIndex(path)],
+            };
             try {
-                sink.writeDataPoint({
-                    doubles: [tApp, cold ? 1 : 0, status],
-                    blobs: [path, colo, method],
-                    indexes: [analyticsIndex(path)],
-                });
+                sink.writeDataPoint(point);
             }
             catch (error) {
                 // Telemetry must never replace an otherwise successful application response with a 500.

package/dist/offline/index.d.ts

@@ -16,3 +16,5 @@ export { assertOfflineJournalCursorRetained, compactOfflineJournal, OfflineJourn
 export type { CompactOfflineJournalOptions, OfflineJournalRetentionCandidate, OfflineJournalRetentionStore, OfflineJournalRetentionTransaction, } from './journal-retention.js';
 export { assertOfflineJournalCoverage, runOfflineJournalMutation } from './journal-mutation.js';
 export type { OfflineJournalMutationChange, OfflineJournalMutationStore, OfflineJournalMutationTransaction, } from './journal-mutation.js';
+export { defineOfflineWireCompatibility, resolveOfflineWireCompatibility } from './wire-compatibility.js';
+export type { OfflineWireAcceptedFingerprint, OfflineWireCompatibility, OfflineWireCompatibilityResolution, OfflineWireFingerprint, } from './wire-compatibility.js';

package/dist/offline/index.js

@@ -12,3 +12,4 @@ export { defineRestDbMethodConverter } from './rest-db-method-converter.js';
 export { decodeOfflineSnapshotCursor, encodeOfflineSnapshotCursor } from './snapshot-cursor.js';
 export { assertOfflineJournalCursorRetained, compactOfflineJournal, OfflineJournalRebaselineRequiredError, } from './journal-retention.js';
 export { assertOfflineJournalCoverage, runOfflineJournalMutation } from './journal-mutation.js';
+export { defineOfflineWireCompatibility, resolveOfflineWireCompatibility } from './wire-compatibility.js';

package/dist/offline/wire-compatibility.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Exact offline wire protocol identity: integer version plus content hash.
+ *
+ * Products own how the hash is computed; this kit never materializes schema
+ * projections or storage. Resolution always requires an exact `{version,hash}` pair.
+ */
+export interface OfflineWireFingerprint {
+    /** Monotonic published protocol version. */
+    readonly version: number;
+    /** Content fingerprint for that published version. */
+    readonly hash: string;
+}
+/**
+ * A previously published fingerprint that remains accepted until an explicit expiry.
+ *
+ * Non-current entries must name the product adapter/projection that serves that wire
+ * shape. Silently allowlisting a hash alone is forbidden.
+ */
+export interface OfflineWireAcceptedFingerprint extends OfflineWireFingerprint {
+    /** Instant at which acceptance ends (exclusive); later clocks reject the fingerprint. */
+    readonly expiresAt: Date;
+    /** Product-owned adapter or projection identifier for this prior wire shape. */
+    readonly adapterId: string;
+}
+/**
+ * Validated current fingerprint plus optional accepted prior fingerprints.
+ *
+ * Produced only by {@link defineOfflineWireCompatibility}.
+ */
+export interface OfflineWireCompatibility {
+    /** The currently published protocol fingerprint. */
+    readonly current: OfflineWireFingerprint;
+    /** Prior fingerprints accepted until their explicit expiry. */
+    readonly accepted: readonly OfflineWireAcceptedFingerprint[];
+}
+/**
+ * Successful resolution of an incoming fingerprint against a compatibility table.
+ *
+ * Unmatched, expired, or inexact fingerprints resolve to `undefined` so products can map
+ * the miss to their own conflict response (for example HTTP 409).
+ */
+export type OfflineWireCompatibilityResolution = {
+    readonly kind: 'current';
+    readonly fingerprint: OfflineWireFingerprint;
+} | {
+    readonly kind: 'accepted';
+    readonly fingerprint: OfflineWireFingerprint;
+    readonly adapterId: string;
+    readonly expiresAt: Date;
+};
+/**
+ * Validates a current fingerprint plus optional accepted prior fingerprints.
+ *
+ * Rejects duplicate versions, duplicate hashes, invalid fingerprints, invalid expiry
+ * instants, and accepted entries that omit a product adapter/projection identifier.
+ *
+ * @param options - Current fingerprint and optional accepted prior fingerprints.
+ * @returns A validated compatibility table safe to pass to {@link resolveOfflineWireCompatibility}.
+ */
+export declare function defineOfflineWireCompatibility(options: {
+    readonly current: OfflineWireFingerprint;
+    readonly accepted?: readonly OfflineWireAcceptedFingerprint[];
+}): OfflineWireCompatibility;
+/**
+ * Resolves an incoming `{version,hash}` against a validated compatibility table.
+ *
+ * Matches only exact fingerprints. Current always wins; accepted prior fingerprints match
+ * only while the injectable clock is strictly before their `expiresAt`.
+ *
+ * @param compatibility - Table from {@link defineOfflineWireCompatibility}.
+ * @param fingerprint - Incoming client fingerprint.
+ * @param clock - Injectable wall clock; defaults to the system wall clock.
+ * @returns The match, or `undefined` when the fingerprint is unknown, inexact, or expired.
+ */
+export declare function resolveOfflineWireCompatibility(compatibility: OfflineWireCompatibility, fingerprint: OfflineWireFingerprint, clock?: () => Date): OfflineWireCompatibilityResolution | undefined;

package/dist/offline/wire-compatibility.js

@@ -0,0 +1,94 @@
+/**
+ * Validates a current fingerprint plus optional accepted prior fingerprints.
+ *
+ * Rejects duplicate versions, duplicate hashes, invalid fingerprints, invalid expiry
+ * instants, and accepted entries that omit a product adapter/projection identifier.
+ *
+ * @param options - Current fingerprint and optional accepted prior fingerprints.
+ * @returns A validated compatibility table safe to pass to {@link resolveOfflineWireCompatibility}.
+ */
+export function defineOfflineWireCompatibility(options) {
+    const current = normalizeFingerprint(options.current, 'current');
+    const acceptedInput = options.accepted ?? [];
+    const versions = new Set([current.version]);
+    const hashes = new Set([current.hash]);
+    const accepted = [];
+    for (const [index, entry] of acceptedInput.entries()) {
+        const label = `accepted[${index}]`;
+        const fingerprint = normalizeFingerprint(entry, label);
+        if (versions.has(fingerprint.version)) {
+            throw new Error(`Offline wire compatibility rejects duplicate version ${fingerprint.version}.`);
+        }
+        if (hashes.has(fingerprint.hash)) {
+            throw new Error(`Offline wire compatibility rejects duplicate hash '${fingerprint.hash}'.`);
+        }
+        if (!(entry.expiresAt instanceof Date) || Number.isNaN(entry.expiresAt.getTime())) {
+            throw new RangeError(`Offline wire compatibility ${label}.expiresAt must be a valid Date.`);
+        }
+        const adapterId = entry.adapterId;
+        if (typeof adapterId !== 'string' || adapterId.trim().length === 0) {
+            throw new Error(`Offline wire compatibility ${label} requires a non-empty product adapter/projection identifier.`);
+        }
+        versions.add(fingerprint.version);
+        hashes.add(fingerprint.hash);
+        accepted.push({
+            version: fingerprint.version,
+            hash: fingerprint.hash,
+            expiresAt: entry.expiresAt,
+            adapterId,
+        });
+    }
+    return { current, accepted };
+}
+/**
+ * Resolves an incoming `{version,hash}` against a validated compatibility table.
+ *
+ * Matches only exact fingerprints. Current always wins; accepted prior fingerprints match
+ * only while the injectable clock is strictly before their `expiresAt`.
+ *
+ * @param compatibility - Table from {@link defineOfflineWireCompatibility}.
+ * @param fingerprint - Incoming client fingerprint.
+ * @param clock - Injectable wall clock; defaults to the system wall clock.
+ * @returns The match, or `undefined` when the fingerprint is unknown, inexact, or expired.
+ */
+export function resolveOfflineWireCompatibility(compatibility, fingerprint, clock = () => new Date()) {
+    const incoming = normalizeFingerprint(fingerprint, 'incoming');
+    if (incoming.version === compatibility.current.version) {
+        if (incoming.hash !== compatibility.current.hash) {
+            return undefined;
+        }
+        return { kind: 'current', fingerprint: compatibility.current };
+    }
+    const now = clock();
+    if (Number.isNaN(now.getTime())) {
+        throw new RangeError('Offline wire compatibility clock must return a valid Date.');
+    }
+    const nowMs = now.getTime();
+    for (const entry of compatibility.accepted) {
+        if (entry.version !== incoming.version) {
+            continue;
+        }
+        if (entry.hash !== incoming.hash) {
+            return undefined;
+        }
+        if (nowMs >= entry.expiresAt.getTime()) {
+            return undefined;
+        }
+        return {
+            kind: 'accepted',
+            fingerprint: { version: entry.version, hash: entry.hash },
+            adapterId: entry.adapterId,
+            expiresAt: entry.expiresAt,
+        };
+    }
+    return undefined;
+}
+function normalizeFingerprint(fingerprint, label) {
+    if (!Number.isSafeInteger(fingerprint.version) || fingerprint.version < 0) {
+        throw new RangeError(`Offline wire compatibility ${label}.version must be a non-negative safe integer.`);
+    }
+    if (typeof fingerprint.hash !== 'string' || fingerprint.hash.trim().length === 0) {
+        throw new Error(`Offline wire compatibility ${label}.hash must be a non-empty string.`);
+    }
+    return { version: fingerprint.version, hash: fingerprint.hash };
+}

package/dist/queue/consumer.js

@@ -69,28 +69,30 @@ export async function processBatch(batch, handler, options) {
     let discarded = 0;
     let failed = 0;
     for (const message of batch.messages) {
-        try {
+        const processMessage = async () => {
             await handler(message.body, message);
             message.ack();
+        };
+        const outcome = await processMessage().then(() => ({ ok: true }), (error) => ({ ok: false, error }));
+        if (outcome.ok) {
             processed++;
+            continue;
+        }
+        try {
+            onError(outcome.error, message);
         }
-        catch (error) {
-            try {
-                onError(error, message);
-            }
-            catch (reportingError) {
-                // Reporting is best-effort. Preserve the domain error's disposition, but never let a broken
-                // custom reporter make a permanent failure disappear without any local trace.
-                console.error(`[queue:${batch.queue}] onError failed for message ${message.id}`, reportingError, 'original error:', error);
-            }
-            if (isNonRetryableQueueError(error)) {
-                message.ack();
-                discarded++;
-                continue;
-            }
-            message.retry(retryOptions);
-            failed++;
+        catch (reportingError) {
+            // Reporting is best-effort. Preserve the domain error's disposition, but never let a broken
+            // custom reporter make a permanent failure disappear without any local trace.
+            console.error(`[queue:${batch.queue}] onError failed for message ${message.id}`, reportingError, 'original error:', outcome.error);
+        }
+        if (isNonRetryableQueueError(outcome.error)) {
+            message.ack();
+            discarded++;
+            continue;
         }
+        message.retry(retryOptions);
+        failed++;
     }
     return { processed, discarded, failed };
 }

package/dist/realtime/retry.js

@@ -27,16 +27,16 @@ export async function retryDurableObjectOperation(operation, options = {}) {
     const random = options.random ?? Math.random;
     const wait = options.wait ?? defaultWait;
     for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
-        try {
-            return await operation(attempt);
+        const invoke = async () => operation(attempt);
+        const outcome = await invoke().then((value) => ({ ok: true, value }), (error) => ({ ok: false, error }));
+        if (outcome.ok) {
+            return outcome.value;
         }
-        catch (error) {
-            if (!isRetryableDurableObjectError(error) || attempt + 1 >= maxAttempts) {
-                throw error;
-            }
-            const delayMs = Math.min(maxDelayMs, baseDelayMs * 2 ** attempt * random());
-            await wait(delayMs);
+        if (!isRetryableDurableObjectError(outcome.error) || attempt + 1 >= maxAttempts) {
+            throw outcome.error;
         }
+        const delayMs = Math.min(maxDelayMs, baseDelayMs * 2 ** attempt * random());
+        await wait(delayMs);
     }
     throw new Error('Durable Object retry exhausted');
 }

package/dist/stripe/failure.js

@@ -162,28 +162,26 @@ export function parsePaymentFailure(receipt) {
     if (!receipt) {
         return null;
     }
+    let parsed;
     try {
-        const parsed = JSON.parse(receipt);
-        const r = asRecord(parsed);
-        if (!r) {
-            return null;
-        }
-        if (asRecord(r.reason)) {
-            if ((r.source !== undefined && typeof r.source !== 'string') ||
-                (r.occurredAt !== undefined && typeof r.occurredAt !== 'string')) {
-                return null;
-            }
-            return parsed;
-        }
-        // IAP rows store the reason itself. `code` is required so arbitrary JSON is not accepted as a reason.
-        if (typeof r.code === 'string') {
-            return { reason: parsed };
-        }
-        return null;
+        parsed = JSON.parse(receipt);
     }
     catch {
         return null;
     }
+    const r = asRecord(parsed);
+    if (!r) {
+        return null;
+    }
+    if (asRecord(r.reason)) {
+        if ((r.source !== undefined && typeof r.source !== 'string') ||
+            (r.occurredAt !== undefined && typeof r.occurredAt !== 'string')) {
+            return null;
+        }
+        return parsed;
+    }
+    // IAP rows store the reason itself. `code` is required so arbitrary JSON is not accepted as a reason.
+    return typeof r.code === 'string' ? { reason: parsed } : null;
 }
 /**
  * HTTP error for a synchronous card decline, carrying a user-facing Japanese message.

package/dist/testing/db.js

@@ -83,14 +83,13 @@ export function createTestDb(options) {
             await pool.query(`INSERT INTO \`${table}\` (${columnList}) VALUES (${placeholders})`, Object.values(row));
         },
         async mysqlReachable() {
-            try {
-                const c = await createConnection({ ...connection });
-                await c.end();
-                return true;
-            }
-            catch {
+            const connect = async () => createConnection({ ...connection });
+            const c = await connect().catch(() => undefined);
+            if (!c) {
                 return false;
             }
+            const close = async () => c.end();
+            return close().then(() => true, () => false);
         },
     };
 }

package/dist/testing/workers-bindings.js

@@ -21,16 +21,14 @@ export function fakeQueue() {
         get batchCount() {
             return batchCount;
         },
-        send(body) {
+        async send(body) {
             sent.push(body);
-            return Promise.resolve();
         },
-        sendBatch(messages) {
+        async sendBatch(messages) {
             batchCount++;
             for (const m of messages) {
                 sent.push(m.body);
             }
-            return Promise.resolve();
         },
     };
 }
@@ -47,16 +45,14 @@ export function fakeQueue() {
 export function fakeKv() {
     const store = new Map();
     return {
-        get: (key) => Promise.resolve(store.get(key) ?? null),
-        put: (key, value) => {
+        get: async (key) => store.get(key) ?? null,
+        put: async (key, value) => {
             store.set(key, value);
-            return Promise.resolve();
         },
-        delete: (key) => {
+        delete: async (key) => {
             store.delete(key);
-            return Promise.resolve();
         },
-        list: () => Promise.resolve({ keys: [], list_complete: true, cacheStatus: null }),
-        getWithMetadata: () => Promise.resolve({ value: null, metadata: null, cacheStatus: null }),
+        list: async () => ({ keys: [], list_complete: true, cacheStatus: null }),
+        getWithMetadata: async () => ({ value: null, metadata: null, cacheStatus: null }),
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rdlabo/workers-hono-kit",
-  "version": "0.10.4",
+  "version": "0.10.6",
   "private": false,
   "publishConfig": {
     "access": "public"
@@ -33,6 +33,13 @@
   "engines": {
     "node": ">=20.0.0"
   },
+  "devEngines": {
+    "runtime": {
+      "name": "node",
+      "version": "^20.19.0 || ^22.13.0 || >=24.0.0",
+      "onFail": "error"
+    }
+  },
   "files": [
     "dist",
     "scripts",
@@ -120,8 +127,13 @@
   "devDependencies": {
     "@ai-sdk/anthropic": "^3.0.84",
     "@ai-sdk/openai": "^3.0.71",
+    "@angular-eslint/template-parser": "^21.4.0",
+    "@angular/core": "^21.2.20",
+    "@angular/forms": "^21.2.20",
+    "@angular/router": "^21.2.20",
     "@hono/eslint-config": "^2.1.0",
     "@hono/zod-validator": "^0.8.0",
+    "@rdlabo/eslint-plugin-rules": "^21.2.6",
     "@types/node": "^22.19.21",
     "ai": "^6.0.204",
     "ai-gateway-provider": "^3.1.3",