@voyant-travel/runtime 0.3.0

package/dist/trust.js

@@ -0,0 +1,49 @@
+import { timingSafeEqual } from "node:crypto";
+/**
+ * Pinned cross-repo constant: the header the platform dispatcher stamps on
+ * every request it forwards to a dedicated (Cloud Run) app. The value is a
+ * per-app shared secret. Do NOT rename — the platform side depends on it.
+ */
+export const ORIGIN_TRUST_HEADER = "x-voyant-origin-trust";
+/**
+ * Constant-time string comparison. Returns `false` for length mismatches
+ * without leaking the comparison via early return timing (the length check is
+ * unavoidable and is itself not secret-length-dependent beyond equality).
+ */
+export function constantTimeEqual(a, b) {
+    const aBytes = new TextEncoder().encode(a);
+    const bBytes = new TextEncoder().encode(b);
+    if (aBytes.length !== bBytes.length) {
+        // Still burn a comparison against a same-length buffer so a size probe
+        // does not short-circuit measurably faster than a value mismatch.
+        timingSafeEqual(aBytes, aBytes);
+        return false;
+    }
+    return timingSafeEqual(aBytes, bBytes);
+}
+/**
+ * Verify that a request carries a valid origin-trust header for `secret`.
+ */
+export function verifyOriginTrust(request, secret) {
+    const provided = request.headers.get(ORIGIN_TRUST_HEADER);
+    if (provided === null)
+        return false;
+    return constantTimeEqual(provided, secret);
+}
+/**
+ * Build a low-level trust gate. Returns a function that, given a request,
+ * yields a `403` {@link Response} when the request must be rejected, or
+ * `undefined` when it may proceed. Composable — used by {@link createNodeServer}
+ * but exported so callers can wire it into their own server loop.
+ */
+export function originTrustMiddleware(secret, options = {}) {
+    const exempt = new Set(options.exemptPaths ?? ["/healthz"]);
+    return (request) => {
+        const { pathname } = new URL(request.url);
+        if (exempt.has(pathname))
+            return undefined;
+        if (verifyOriginTrust(request, secret))
+            return undefined;
+        return new Response("Forbidden: invalid origin trust", { status: 403 });
+    };
+}

package/dist/trust.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=trust.test.d.ts.map

package/dist/trust.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trust.test.d.ts","sourceRoot":"","sources":["../src/trust.test.ts"],"names":[],"mappings":""}

package/dist/trust.test.js

@@ -0,0 +1,42 @@
+import { describe, expect, it } from "vitest";
+import { constantTimeEqual, ORIGIN_TRUST_HEADER, originTrustMiddleware, verifyOriginTrust, } from "./trust.js";
+function req(headers = {}, path = "/v1/admin/x") {
+    return new Request(`https://app.example.com${path}`, { headers });
+}
+describe("constantTimeEqual", () => {
+    it("returns true for equal strings", () => {
+        expect(constantTimeEqual("abc", "abc")).toBe(true);
+    });
+    it("returns false for different values and lengths", () => {
+        expect(constantTimeEqual("abc", "abd")).toBe(false);
+        expect(constantTimeEqual("abc", "abcd")).toBe(false);
+        expect(constantTimeEqual("", "x")).toBe(false);
+    });
+});
+describe("verifyOriginTrust", () => {
+    it("passes when the header matches the secret", () => {
+        expect(verifyOriginTrust(req({ [ORIGIN_TRUST_HEADER]: "s3cr3t" }), "s3cr3t")).toBe(true);
+    });
+    it("fails when header is missing or wrong", () => {
+        expect(verifyOriginTrust(req(), "s3cr3t")).toBe(false);
+        expect(verifyOriginTrust(req({ [ORIGIN_TRUST_HEADER]: "nope" }), "s3cr3t")).toBe(false);
+    });
+});
+describe("originTrustMiddleware", () => {
+    it("rejects unauthenticated requests with 403", () => {
+        const gate = originTrustMiddleware("s3cr3t");
+        const rejection = gate(req());
+        expect(rejection?.status).toBe(403);
+    });
+    it("allows authenticated requests through (undefined)", () => {
+        const gate = originTrustMiddleware("s3cr3t");
+        expect(gate(req({ [ORIGIN_TRUST_HEADER]: "s3cr3t" }))).toBeUndefined();
+    });
+    it("exempts configured paths", () => {
+        const gate = originTrustMiddleware("s3cr3t", { exemptPaths: ["/healthz"] });
+        expect(gate(req({}, "/healthz"))).toBeUndefined();
+    });
+    it("uses the pinned header name", () => {
+        expect(ORIGIN_TRUST_HEADER).toBe("x-voyant-origin-trust");
+    });
+});

package/dist/types.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Minimal structural slice of the Cloudflare `ExecutionContext`. Only
+ * `waitUntil` is required by this package; the full context object is passed
+ * through to apps untouched, so any richer context type remains compatible.
+ */
+export interface WaitUntilContext {
+    waitUntil(promise: Promise<unknown>): void;
+}
+/**
+ * Anything with a Worker-style `fetch` — a Hono app, a Better Auth handler,
+ * or a plain `{ fetch }` module default export.
+ */
+export interface FetchApp<Env = unknown, Ctx extends WaitUntilContext = WaitUntilContext> {
+    fetch(request: Request, env?: Env, ctx?: Ctx): Response | Promise<Response>;
+}
+/**
+ * Lazily resolves a {@link FetchApp}. Loaders own the dynamic `import()` of
+ * app modules so the Worker entry stays out of the API graph until a request
+ * actually needs it.
+ */
+export type AppLoader<Env = unknown, Ctx extends WaitUntilContext = WaitUntilContext> = () => Promise<FetchApp<Env, Ctx>>;
+/**
+ * Structural slice of the Cloudflare Workers `ExecutionContext`. On a resident
+ * Node process we can ship a *real* {@link ExecutionContextLike.waitUntil} that
+ * tracks background work for graceful shutdown, instead of running subscriber
+ * work inline (which adds request latency) or dropping it on exit.
+ */
+export interface ExecutionContextLike extends WaitUntilContext {
+    /**
+     * No-op on Node — kept for source-compatibility with app code that calls
+     * `ctx.passThroughOnException()` on Workers.
+     */
+    passThroughOnException?(): void;
+}
+/**
+ * Worker-style `fetch(request, env, ctx)` entrypoint. This is the exact shape
+ * an operator app exports; the whole point of this package is that the same
+ * handler runs unchanged on Node via {@link createNodeServer}.
+ */
+export type FetchHandler<Env> = (request: Request, env: Env, ctx: ExecutionContextLike) => Response | Promise<Response>;
+/**
+ * The event object passed to a Worker `scheduled()` handler. On Cloud Run the
+ * cron triggers arrive over HTTP (Cloud Scheduler), so `scheduledTime` is the
+ * dispatch time and `cron` is echoed from the request.
+ */
+export interface ScheduledEventLike {
+    cron: string;
+    scheduledTime: number;
+}
+/**
+ * Worker-style `scheduled(event, env, ctx)` handler.
+ */
+export type ScheduledHandler<Env> = (event: ScheduledEventLike, env: Env, ctx: ExecutionContextLike) => void | Promise<void>;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAC/B,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC,OAAO,CAAC,GAAG,IAAI,CAAA;CAC3C;AAED;;;GAGG;AACH,MAAM,WAAW,QAAQ,CAAC,GAAG,GAAG,OAAO,EAAE,GAAG,SAAS,gBAAgB,GAAG,gBAAgB;IACtF,KAAK,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,CAAC,EAAE,GAAG,EAAE,GAAG,CAAC,EAAE,GAAG,GAAG,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAA;CAC5E;AAED;;;;GAIG;AACH,MAAM,MAAM,SAAS,CACnB,GAAG,GAAG,OAAO,EACb,GAAG,SAAS,gBAAgB,GAAG,gBAAgB,IAC7C,MAAM,OAAO,CAAC,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAA;AAErC;;;;;GAKG;AACH,MAAM,WAAW,oBAAqB,SAAQ,gBAAgB;IAC5D;;;OAGG;IACH,sBAAsB,CAAC,IAAI,IAAI,CAAA;CAChC;AAED;;;;GAIG;AACH,MAAM,MAAM,YAAY,CAAC,GAAG,IAAI,CAC9B,OAAO,EAAE,OAAO,EAChB,GAAG,EAAE,GAAG,EACR,GAAG,EAAE,oBAAoB,KACtB,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAA;AAEjC;;;;GAIG;AACH,MAAM,WAAW,kBAAkB;IACjC,IAAI,EAAE,MAAM,CAAA;IACZ,aAAa,EAAE,MAAM,CAAA;CACtB;AAED;;GAEG;AACH,MAAM,MAAM,gBAAgB,CAAC,GAAG,IAAI,CAClC,KAAK,EAAE,kBAAkB,EACzB,GAAG,EAAE,GAAG,EACR,GAAG,EAAE,oBAAoB,KACtB,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA"}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/wait-until.d.ts

@@ -0,0 +1,25 @@
+import type { ExecutionContextLike } from "./types.js";
+export interface WaitUntilRegistry {
+    /**
+     * Produce a fresh {@link ExecutionContextLike} for a single request. Every
+     * promise passed to its `waitUntil` is tracked centrally so the process can
+     * drain in-flight background work on shutdown.
+     */
+    context(): ExecutionContextLike;
+    /**
+     * Wait for all currently-tracked promises to settle, or until `timeoutMs`
+     * elapses — whichever comes first. Resolves (never rejects); individual
+     * promise rejections are swallowed here since `waitUntil` work is
+     * fire-and-forget by the Workers contract.
+     */
+    drain(timeoutMs?: number): Promise<void>;
+    /** Number of promises still in flight. Useful for tests and readiness. */
+    pending(): number;
+}
+/**
+ * Track every `waitUntil` promise across requests so a resident Node process
+ * can drain background work (outbox publishes, cache warms, event-bus fan-out)
+ * before it exits — the behavior Cloudflare gives for free but Node does not.
+ */
+export declare function createWaitUntilRegistry(): WaitUntilRegistry;
+//# sourceMappingURL=wait-until.d.ts.map

package/dist/wait-until.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wait-until.d.ts","sourceRoot":"","sources":["../src/wait-until.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAA;AAEtD,MAAM,WAAW,iBAAiB;IAChC;;;;OAIG;IACH,OAAO,IAAI,oBAAoB,CAAA;IAC/B;;;;;OAKG;IACH,KAAK,CAAC,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IACxC,0EAA0E;IAC1E,OAAO,IAAI,MAAM,CAAA;CAClB;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,IAAI,iBAAiB,CA4C3D"}

package/dist/wait-until.js

@@ -0,0 +1,50 @@
+/**
+ * Track every `waitUntil` promise across requests so a resident Node process
+ * can drain background work (outbox publishes, cache warms, event-bus fan-out)
+ * before it exits — the behavior Cloudflare gives for free but Node does not.
+ */
+export function createWaitUntilRegistry() {
+    const inflight = new Set();
+    function track(promise) {
+        const tracked = Promise.resolve(promise).catch(() => {
+            // waitUntil work is fire-and-forget; never let a rejection escape.
+        });
+        inflight.add(tracked);
+        void tracked.finally(() => {
+            inflight.delete(tracked);
+        });
+    }
+    return {
+        context() {
+            return {
+                waitUntil(promise) {
+                    track(promise);
+                },
+                passThroughOnException() {
+                    // no-op on Node
+                },
+            };
+        },
+        async drain(timeoutMs = 10_000) {
+            if (inflight.size === 0)
+                return;
+            const settled = Promise.allSettled([...inflight]).then(() => undefined);
+            if (timeoutMs <= 0) {
+                await settled;
+                return;
+            }
+            let timer;
+            const timeout = new Promise((resolve) => {
+                timer = setTimeout(resolve, timeoutMs);
+                // Do not keep the event loop alive purely for the drain timeout.
+                timer.unref?.();
+            });
+            await Promise.race([settled, timeout]);
+            if (timer)
+                clearTimeout(timer);
+        },
+        pending() {
+            return inflight.size;
+        },
+    };
+}

package/dist/wait-until.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=wait-until.test.d.ts.map

package/dist/wait-until.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wait-until.test.d.ts","sourceRoot":"","sources":["../src/wait-until.test.ts"],"names":[],"mappings":""}

package/dist/wait-until.test.js

@@ -0,0 +1,40 @@
+import { describe, expect, it } from "vitest";
+import { createWaitUntilRegistry } from "./wait-until.js";
+const tick = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+describe("createWaitUntilRegistry", () => {
+    it("tracks pending promises and drains them", async () => {
+        const registry = createWaitUntilRegistry();
+        const ctx = registry.context();
+        let done = false;
+        ctx.waitUntil(tick(20).then(() => (done = true)));
+        expect(registry.pending()).toBe(1);
+        await registry.drain(1000);
+        expect(done).toBe(true);
+        expect(registry.pending()).toBe(0);
+    });
+    it("resolves immediately when nothing is in flight", async () => {
+        const registry = createWaitUntilRegistry();
+        await expect(registry.drain(1000)).resolves.toBeUndefined();
+    });
+    it("stops waiting after the timeout for slow work", async () => {
+        const registry = createWaitUntilRegistry();
+        registry.context().waitUntil(tick(5000));
+        const start = Date.now();
+        await registry.drain(30);
+        expect(Date.now() - start).toBeLessThan(1000);
+    });
+    it("swallows rejections so drain never throws", async () => {
+        const registry = createWaitUntilRegistry();
+        registry.context().waitUntil(Promise.reject(new Error("boom")));
+        await expect(registry.drain(1000)).resolves.toBeUndefined();
+        expect(registry.pending()).toBe(0);
+    });
+    it("shares one registry across multiple request contexts", async () => {
+        const registry = createWaitUntilRegistry();
+        registry.context().waitUntil(tick(10));
+        registry.context().waitUntil(tick(10));
+        expect(registry.pending()).toBe(2);
+        await registry.drain(1000);
+        expect(registry.pending()).toBe(0);
+    });
+});

package/dist/worker-fetch.d.ts

@@ -0,0 +1,31 @@
+import { type ApiDispatch, type CreateApiDispatchOptions } from "./api-dispatch.js";
+import type { WaitUntilContext } from "./types.js";
+export type SsrHandler<Env, Ctx extends WaitUntilContext = WaitUntilContext> = (request: Request, env: Env, ctx: Ctx) => Response | Promise<Response>;
+/** Loads the real SSR handler. Wrap with {@link lazySsr}. */
+export type SsrLoader<Env, Ctx extends WaitUntilContext = WaitUntilContext> = () => Promise<SsrHandler<Env, Ctx>>;
+/**
+ * Memoize an SSR-handler loader so the dynamic `import()` of the TanStack Start
+ * server graph — React + `react-dom/server` — runs once per isolate and stays
+ * OUT of the Worker's startup graph. The SSR handler is only invoked on
+ * non-API requests, so API-only isolates never load the React SSR graph at all:
+ * the same win `lazyApp` gives the Hono API, applied to the SSR half.
+ *
+ * Without this, `entry.ts` statically importing `@tanstack/react-start/server`
+ * pulls ~2.2 MB of React/`react-dom/server` into module global scope, which
+ * Cloudflare parses on every cold isolate before it can answer even
+ * `/api/health`.
+ */
+export declare function lazySsr<Env, Ctx extends WaitUntilContext = WaitUntilContext>(load: SsrLoader<Env, Ctx>): SsrHandler<Env, Ctx>;
+export interface CreateWorkerFetchOptions<Env, Ctx extends WaitUntilContext = WaitUntilContext> {
+    /** An {@link ApiDispatch} instance, or options to build one. */
+    api: ApiDispatch<Env, Ctx> | CreateApiDispatchOptions<Env, Ctx>;
+    /** Handles every non-API request (typically the SSR start handler). */
+    ssr: SsrHandler<Env, Ctx>;
+}
+/**
+ * The Worker `fetch` entrypoint: API-prefixed requests go through the
+ * prefix-stripping dispatch, everything else goes to SSR. The app's
+ * `entry.ts` shrinks to bindings plus this factory call.
+ */
+export declare function createWorkerFetch<Env, Ctx extends WaitUntilContext = WaitUntilContext>(options: CreateWorkerFetchOptions<Env, Ctx>): (request: Request, env: Env, ctx: Ctx) => Promise<Response>;
+//# sourceMappingURL=worker-fetch.d.ts.map

package/dist/worker-fetch.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker-fetch.d.ts","sourceRoot":"","sources":["../src/worker-fetch.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,WAAW,EAChB,KAAK,wBAAwB,EAE9B,MAAM,mBAAmB,CAAA;AAC1B,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAElD,MAAM,MAAM,UAAU,CAAC,GAAG,EAAE,GAAG,SAAS,gBAAgB,GAAG,gBAAgB,IAAI,CAC7E,OAAO,EAAE,OAAO,EAChB,GAAG,EAAE,GAAG,EACR,GAAG,EAAE,GAAG,KACL,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAA;AAEjC,6DAA6D;AAC7D,MAAM,MAAM,SAAS,CAAC,GAAG,EAAE,GAAG,SAAS,gBAAgB,GAAG,gBAAgB,IAAI,MAAM,OAAO,CACzF,UAAU,CAAC,GAAG,EAAE,GAAG,CAAC,CACrB,CAAA;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,OAAO,CAAC,GAAG,EAAE,GAAG,SAAS,gBAAgB,GAAG,gBAAgB,EAC1E,IAAI,EAAE,SAAS,CAAC,GAAG,EAAE,GAAG,CAAC,GACxB,UAAU,CAAC,GAAG,EAAE,GAAG,CAAC,CAMtB;AAED,MAAM,WAAW,wBAAwB,CAAC,GAAG,EAAE,GAAG,SAAS,gBAAgB,GAAG,gBAAgB;IAC5F,gEAAgE;IAChE,GAAG,EAAE,WAAW,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,wBAAwB,CAAC,GAAG,EAAE,GAAG,CAAC,CAAA;IAC/D,uEAAuE;IACvE,GAAG,EAAE,UAAU,CAAC,GAAG,EAAE,GAAG,CAAC,CAAA;CAC1B;AAQD;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,GAAG,SAAS,gBAAgB,GAAG,gBAAgB,EACpF,OAAO,EAAE,wBAAwB,CAAC,GAAG,EAAE,GAAG,CAAC,GAC1C,CAAC,OAAO,EAAE,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,KAAK,OAAO,CAAC,QAAQ,CAAC,CAS7D"}

package/dist/worker-fetch.js

@@ -0,0 +1,37 @@
+import { createApiDispatch, } from "./api-dispatch.js";
+/**
+ * Memoize an SSR-handler loader so the dynamic `import()` of the TanStack Start
+ * server graph — React + `react-dom/server` — runs once per isolate and stays
+ * OUT of the Worker's startup graph. The SSR handler is only invoked on
+ * non-API requests, so API-only isolates never load the React SSR graph at all:
+ * the same win `lazyApp` gives the Hono API, applied to the SSR half.
+ *
+ * Without this, `entry.ts` statically importing `@tanstack/react-start/server`
+ * pulls ~2.2 MB of React/`react-dom/server` into module global scope, which
+ * Cloudflare parses on every cold isolate before it can answer even
+ * `/api/health`.
+ */
+export function lazySsr(load) {
+    let promise;
+    return (request, env, ctx) => {
+        promise ??= load();
+        return promise.then((handler) => handler(request, env, ctx));
+    };
+}
+function isApiDispatch(api) {
+    return "dispatch" in api;
+}
+/**
+ * The Worker `fetch` entrypoint: API-prefixed requests go through the
+ * prefix-stripping dispatch, everything else goes to SSR. The app's
+ * `entry.ts` shrinks to bindings plus this factory call.
+ */
+export function createWorkerFetch(options) {
+    const api = isApiDispatch(options.api) ? options.api : createApiDispatch(options.api);
+    return async (request, env, ctx) => {
+        if (api.isApiRequest(new URL(request.url).pathname)) {
+            return api.dispatch(request, env, ctx);
+        }
+        return options.ssr(request, env, ctx);
+    };
+}

package/package.json

@@ -0,0 +1,114 @@
+{
+  "name": "@voyant-travel/runtime",
+  "version": "0.3.0",
+  "license": "Apache-2.0",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": "./src/index.ts",
+    "./api-dispatch": "./src/api-dispatch.ts",
+    "./ssr-manifest": "./src/ssr-manifest.ts",
+    "./worker-fetch": "./src/worker-fetch.ts",
+    "./node-server": "./src/node-server.ts",
+    "./trust": "./src/trust.ts",
+    "./wait-until": "./src/wait-until.ts",
+    "./env": "./src/env.ts",
+    "./memory-kv": "./src/memory-kv.ts",
+    "./memory-r2": "./src/memory-r2.ts",
+    "./r2": "./src/r2.ts",
+    "./types": "./src/types.ts"
+  },
+  "scripts": {
+    "typecheck": "tsc -p tsconfig.typecheck.json",
+    "lint": "biome check src/ tests/",
+    "test": "vitest run",
+    "build": "tsc -p tsconfig.build.json",
+    "clean": "rm -rf dist tsconfig.tsbuildinfo",
+    "prepack": "pnpm run build"
+  },
+  "files": [
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public",
+    "exports": {
+      ".": {
+        "types": "./dist/index.d.ts",
+        "import": "./dist/index.js",
+        "default": "./dist/index.js"
+      },
+      "./api-dispatch": {
+        "types": "./dist/api-dispatch.d.ts",
+        "import": "./dist/api-dispatch.js",
+        "default": "./dist/api-dispatch.js"
+      },
+      "./ssr-manifest": {
+        "types": "./dist/ssr-manifest.d.ts",
+        "import": "./dist/ssr-manifest.js",
+        "default": "./dist/ssr-manifest.js"
+      },
+      "./worker-fetch": {
+        "types": "./dist/worker-fetch.d.ts",
+        "import": "./dist/worker-fetch.js",
+        "default": "./dist/worker-fetch.js"
+      },
+      "./node-server": {
+        "types": "./dist/node-server.d.ts",
+        "import": "./dist/node-server.js",
+        "default": "./dist/node-server.js"
+      },
+      "./trust": {
+        "types": "./dist/trust.d.ts",
+        "import": "./dist/trust.js",
+        "default": "./dist/trust.js"
+      },
+      "./wait-until": {
+        "types": "./dist/wait-until.d.ts",
+        "import": "./dist/wait-until.js",
+        "default": "./dist/wait-until.js"
+      },
+      "./env": {
+        "types": "./dist/env.d.ts",
+        "import": "./dist/env.js",
+        "default": "./dist/env.js"
+      },
+      "./memory-kv": {
+        "types": "./dist/memory-kv.d.ts",
+        "import": "./dist/memory-kv.js",
+        "default": "./dist/memory-kv.js"
+      },
+      "./memory-r2": {
+        "types": "./dist/memory-r2.d.ts",
+        "import": "./dist/memory-r2.js",
+        "default": "./dist/memory-r2.js"
+      },
+      "./r2": {
+        "types": "./dist/r2.d.ts",
+        "import": "./dist/r2.js",
+        "default": "./dist/r2.js"
+      },
+      "./types": {
+        "types": "./dist/types.d.ts",
+        "import": "./dist/types.js",
+        "default": "./dist/types.js"
+      }
+    },
+    "main": "./dist/index.js",
+    "types": "./dist/index.d.ts"
+  },
+  "dependencies": {
+    "@hono/node-server": "^2.0.6",
+    "@voyant-travel/storage": "workspace:^"
+  },
+  "devDependencies": {
+    "@types/node": "catalog:",
+    "@voyant-travel/voyant-typescript-config": "workspace:^",
+    "typescript": "catalog:",
+    "vitest": "catalog:"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/voyant-travel/voyant.git",
+    "directory": "packages/runtime"
+  }
+}