rivetkit 2.0.40 → 2.0.42

package/dist/tsup/serve-test-suite/mod.js

@@ -0,0 +1,1496 @@
+import {
+  hibernationActor,
+  logger,
+  sleep,
+  sleepWithLongRpc,
+  sleepWithNoSleepOption,
+  sleepWithRawHttp,
+  sleepWithRawWebSocket
+} from "../chunk-TCOEBUUE.js";
+import {
+  actor,
+  setup
+} from "../chunk-JDAD2YFA.js";
+import {
+  createFileSystemOrMemoryDriver
+} from "../chunk-KCOVZOPS.js";
+import "../chunk-Q6W7RJJP.js";
+import "../chunk-XXGJCOL6.js";
+import {
+  buildManagerRouter
+} from "../chunk-GMAVRZSF.js";
+import "../chunk-E6ZE2YEA.js";
+import "../chunk-FJ3KTN4V.js";
+import {
+  UserError
+} from "../chunk-LFVF5SCU.js";
+
+// src/serve-test-suite/mod.ts
+import { serve as honoServe } from "@hono/node-server";
+import { createNodeWebSocket } from "@hono/node-ws";
+import { createServer } from "net";
+import { fileURLToPath } from "url";
+import invariant from "invariant";
+
+// fixtures/driver-test-suite/action-inputs.ts
+var inputActor = actor({
+  createState: (c, input) => {
+    return {
+      initialInput: input,
+      onCreateInput: void 0
+    };
+  },
+  onCreate: (c, input) => {
+    c.state.onCreateInput = input;
+  },
+  actions: {
+    getInputs: (c) => {
+      return {
+        initialInput: c.state.initialInput,
+        onCreateInput: c.state.onCreateInput
+      };
+    }
+  }
+});
+
+// fixtures/driver-test-suite/action-timeout.ts
+var shortTimeoutActor = actor({
+  state: { value: 0 },
+  options: {
+    actionTimeout: 50
+    // 50ms timeout
+  },
+  actions: {
+    quickAction: async (c) => {
+      return "quick response";
+    },
+    slowAction: async (c) => {
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      return "slow response";
+    }
+  }
+});
+var longTimeoutActor = actor({
+  state: { value: 0 },
+  options: {
+    actionTimeout: 200
+    // 200ms timeout
+  },
+  actions: {
+    delayedAction: async (c) => {
+      await new Promise((resolve) => setTimeout(resolve, 100));
+      return "delayed response";
+    }
+  }
+});
+var defaultTimeoutActor = actor({
+  state: { value: 0 },
+  actions: {
+    normalAction: async (c) => {
+      await new Promise((resolve) => setTimeout(resolve, 50));
+      return "normal response";
+    }
+  }
+});
+var syncTimeoutActor = actor({
+  state: { value: 0 },
+  options: {
+    actionTimeout: 50
+    // 50ms timeout
+  },
+  actions: {
+    syncAction: (c) => {
+      return "sync response";
+    }
+  }
+});
+
+// fixtures/driver-test-suite/action-types.ts
+var syncActionActor = actor({
+  state: { value: 0 },
+  actions: {
+    // Simple synchronous action that returns a value directly
+    increment: (c, amount = 1) => {
+      c.state.value += amount;
+      return c.state.value;
+    },
+    // Synchronous action that returns an object
+    getInfo: (c) => {
+      return {
+        currentValue: c.state.value,
+        timestamp: Date.now()
+      };
+    },
+    // Synchronous action with no return value (void)
+    reset: (c) => {
+      c.state.value = 0;
+    }
+  }
+});
+var asyncActionActor = actor({
+  state: { value: 0, data: null },
+  actions: {
+    // Async action with a delay
+    delayedIncrement: async (c, amount = 1) => {
+      await Promise.resolve();
+      c.state.value += amount;
+      return c.state.value;
+    },
+    // Async action that simulates an API call
+    fetchData: async (c, id) => {
+      await Promise.resolve();
+      const data = { id, timestamp: Date.now() };
+      c.state.data = data;
+      return data;
+    },
+    // Async action with error handling
+    asyncWithError: async (c, shouldError) => {
+      await Promise.resolve();
+      if (shouldError) {
+        throw new UserError("Intentional error");
+      }
+      return "Success";
+    }
+  }
+});
+var promiseActor = actor({
+  state: { results: [] },
+  actions: {
+    // Action that returns a resolved promise
+    resolvedPromise: (c) => {
+      return Promise.resolve("resolved value");
+    },
+    // Action that returns a promise that resolves after a delay
+    delayedPromise: (c) => {
+      return new Promise((resolve) => {
+        c.state.results.push("delayed");
+        resolve("delayed value");
+      });
+    },
+    // Action that returns a rejected promise
+    rejectedPromise: (c) => {
+      return Promise.reject(new UserError("promised rejection"));
+    },
+    // Action to check the collected results
+    getResults: (c) => {
+      return c.state.results;
+    }
+  }
+});
+
+// fixtures/driver-test-suite/actor-onstatechange.ts
+var onStateChangeActor = actor({
+  state: {
+    value: 0,
+    changeCount: 0
+  },
+  actions: {
+    // Action that modifies state - should trigger onStateChange
+    setValue: (c, newValue) => {
+      c.state.value = newValue;
+      return c.state.value;
+    },
+    // Action that modifies state multiple times - should trigger onStateChange for each change
+    incrementMultiple: (c, times) => {
+      for (let i = 0; i < times; i++) {
+        c.state.value++;
+      }
+      return c.state.value;
+    },
+    // Action that doesn't modify state - should NOT trigger onStateChange
+    getValue: (c) => {
+      return c.state.value;
+    },
+    // Action that reads and returns without modifying - should NOT trigger onStateChange
+    getDoubled: (c) => {
+      const doubled = c.state.value * 2;
+      return doubled;
+    },
+    // Get the count of how many times onStateChange was called
+    getChangeCount: (c) => {
+      return c.state.changeCount;
+    },
+    // Reset change counter for testing
+    resetChangeCount: (c) => {
+      c.state.changeCount = 0;
+    }
+  },
+  // Track onStateChange calls
+  onStateChange: (c) => {
+    c.state.changeCount++;
+  }
+});
+
+// fixtures/driver-test-suite/conn-params.ts
+var counterWithParams = actor({
+  state: { count: 0, initializers: [] },
+  createConnState: (c, params) => {
+    return {
+      name: params.name || "anonymous"
+    };
+  },
+  onConnect: (c, conn) => {
+    c.state.initializers.push(conn.state.name);
+  },
+  actions: {
+    increment: (c, x) => {
+      c.state.count += x;
+      c.broadcast("newCount", {
+        count: c.state.count,
+        by: c.conn.state.name
+      });
+      return c.state.count;
+    },
+    getInitializers: (c) => {
+      return c.state.initializers;
+    }
+  }
+});
+
+// fixtures/driver-test-suite/conn-state.ts
+var connStateActor = actor({
+  state: {
+    sharedCounter: 0,
+    disconnectionCount: 0
+  },
+  // Define connection state
+  createConnState: (c, params) => {
+    return {
+      username: (params == null ? void 0 : params.username) || "anonymous",
+      role: (params == null ? void 0 : params.role) || "user",
+      counter: 0,
+      createdAt: Date.now(),
+      noCount: (params == null ? void 0 : params.noCount) ?? false
+    };
+  },
+  // Lifecycle hook when a connection is established
+  onConnect: (c, conn) => {
+    c.broadcast("userConnected", {
+      id: conn.id,
+      username: "anonymous",
+      role: "user"
+    });
+  },
+  // Lifecycle hook when a connection is closed
+  onDisconnect: (c, conn) => {
+    var _a;
+    if (!((_a = conn.state) == null ? void 0 : _a.noCount)) {
+      c.state.disconnectionCount += 1;
+      c.broadcast("userDisconnected", {
+        id: conn.id
+      });
+    }
+  },
+  actions: {
+    // Action to increment the connection's counter
+    incrementConnCounter: (c, amount = 1) => {
+      c.conn.state.counter += amount;
+    },
+    // Action to increment the shared counter
+    incrementSharedCounter: (c, amount = 1) => {
+      c.state.sharedCounter += amount;
+      return c.state.sharedCounter;
+    },
+    // Get the connection state
+    getConnectionState: (c) => {
+      return { id: c.conn.id, ...c.conn.state };
+    },
+    // Check all active connections
+    getConnectionIds: (c) => {
+      return c.conns.entries().filter((c2) => {
+        var _a;
+        return !((_a = c2[1].state) == null ? void 0 : _a.noCount);
+      }).map((x) => x[0]).toArray();
+    },
+    // Get disconnection count
+    getDisconnectionCount: (c) => {
+      return c.state.disconnectionCount;
+    },
+    // Get all active connection states
+    getAllConnectionStates: (c) => {
+      return c.conns.entries().map(([id, conn]) => ({ id, ...conn.state })).toArray();
+    },
+    // Send message to a specific connection with matching ID
+    sendToConnection: (c, targetId, message) => {
+      if (c.conns.has(targetId)) {
+        c.conns.get(targetId).send("directMessage", { from: c.conn.id, message });
+        return true;
+      } else {
+        return false;
+      }
+    },
+    // Update connection state (simulated for tests)
+    updateConnection: (c, updates) => {
+      if (updates.username) c.conn.state.username = updates.username;
+      if (updates.role) c.conn.state.role = updates.role;
+      return c.conn.state;
+    },
+    disconnectSelf: (c, reason) => {
+      c.conn.disconnect(reason ?? "test.disconnect");
+      return true;
+    }
+  }
+});
+
+// fixtures/driver-test-suite/counter.ts
+var counter = actor({
+  state: { count: 0 },
+  actions: {
+    increment: (c, x) => {
+      c.state.count += x;
+      c.broadcast("newCount", c.state.count);
+      return c.state.count;
+    },
+    setCount: (c, x) => {
+      c.state.count = x;
+      c.broadcast("newCount", x);
+      return c.state.count;
+    },
+    getCount: (c) => {
+      return c.state.count;
+    }
+  }
+});
+
+// fixtures/driver-test-suite/counter-conn.ts
+var counterConn = actor({
+  state: {
+    connectionCount: 0
+  },
+  connState: { count: 0 },
+  onConnect: (c, conn) => {
+    c.state.connectionCount += 1;
+  },
+  onDisconnect: (c, conn) => {
+    c.state.connectionCount -= 1;
+  },
+  actions: {
+    increment: (c, x) => {
+      c.conn.state.count += x;
+      c.broadcast("newCount", c.conn.state.count);
+    },
+    setCount: (c, x) => {
+      c.conn.state.count = x;
+      c.broadcast("newCount", x);
+    },
+    getCount: (c) => {
+      return c.conn.state.count;
+    },
+    getConnectionCount: (c) => {
+      return c.state.connectionCount;
+    }
+  }
+});
+
+// fixtures/driver-test-suite/destroy.ts
+var destroyObserver = actor({
+  state: { destroyedActors: [] },
+  actions: {
+    notifyDestroyed: (c, actorKey) => {
+      c.state.destroyedActors.push(actorKey);
+    },
+    wasDestroyed: (c, actorKey) => {
+      return c.state.destroyedActors.includes(actorKey);
+    },
+    reset: (c) => {
+      c.state.destroyedActors = [];
+    }
+  }
+});
+var destroyActor = actor({
+  state: { value: 0, key: "" },
+  onWake: (c) => {
+    c.state.key = c.key.join("/");
+  },
+  onDestroy: async (c) => {
+    const client = c.client();
+    const observer = client.destroyObserver.getOrCreate(["observer"]);
+    await observer.notifyDestroyed(c.state.key);
+  },
+  actions: {
+    setValue: async (c, newValue) => {
+      c.state.value = newValue;
+      await c.saveState({ immediate: true });
+      return c.state.value;
+    },
+    getValue: (c) => {
+      return c.state.value;
+    },
+    destroy: (c) => {
+      c.destroy();
+    }
+  }
+});
+
+// fixtures/driver-test-suite/error-handling.ts
+var errorHandlingActor = actor({
+  state: {
+    errorLog: []
+  },
+  actions: {
+    // Action that throws a UserError with just a message
+    throwSimpleError: () => {
+      throw new UserError("Simple error message");
+    },
+    // Action that throws a UserError with code and metadata
+    throwDetailedError: () => {
+      throw new UserError("Detailed error message", {
+        code: "detailed_error",
+        metadata: {
+          reason: "test",
+          timestamp: Date.now()
+        }
+      });
+    },
+    // Action that throws an internal error
+    throwInternalError: () => {
+      throw new Error("This is an internal error");
+    },
+    // Action that returns successfully
+    successfulAction: () => {
+      return "success";
+    },
+    // Action that times out (simulated with a long delay)
+    timeoutAction: async (c) => {
+      return new Promise((resolve) => {
+        setTimeout(() => {
+          resolve("This should not be reached if timeout works");
+        }, 1e4);
+      });
+    },
+    // Action with configurable delay to test timeout edge cases
+    delayedAction: async (c, delayMs) => {
+      return new Promise((resolve) => {
+        setTimeout(() => {
+          resolve(`Completed after ${delayMs}ms`);
+        }, delayMs);
+      });
+    },
+    // Log an error for inspection
+    logError: (c, error) => {
+      c.state.errorLog.push(error);
+      return c.state.errorLog;
+    },
+    // Get the error log
+    getErrorLog: (c) => {
+      return c.state.errorLog;
+    },
+    // Clear the error log
+    clearErrorLog: (c) => {
+      c.state.errorLog = [];
+      return true;
+    }
+  },
+  options: {
+    actionTimeout: 500
+    // 500ms timeout for actions
+  }
+});
+var customTimeoutActor = actor({
+  state: {},
+  actions: {
+    quickAction: async () => {
+      await new Promise((resolve) => setTimeout(resolve, 50));
+      return "Quick action completed";
+    },
+    slowAction: async () => {
+      await new Promise((resolve) => setTimeout(resolve, 300));
+      return "Slow action completed";
+    }
+  },
+  options: {
+    actionTimeout: 200
+    // 200ms timeout
+  }
+});
+
+// fixtures/driver-test-suite/inline-client.ts
+var inlineClientActor = actor({
+  state: { messages: [] },
+  actions: {
+    // Action that uses client to call another actor (stateless)
+    callCounterIncrement: async (c, amount) => {
+      const client = c.client();
+      const result = await client.counter.getOrCreate(["inline-test"]).increment(amount);
+      c.state.messages.push(
+        `Called counter.increment(${amount}), result: ${result}`
+      );
+      return result;
+    },
+    // Action that uses client to get counter state (stateless)
+    getCounterState: async (c) => {
+      const client = c.client();
+      const count = await client.counter.getOrCreate(["inline-test"]).getCount();
+      c.state.messages.push(`Got counter state: ${count}`);
+      return count;
+    },
+    // Action that uses client with .connect() for stateful communication
+    connectToCounterAndIncrement: async (c, amount) => {
+      const client = c.client();
+      const handle = client.counter.getOrCreate(["inline-test-stateful"]);
+      const connection = handle.connect();
+      const events = [];
+      connection.on("newCount", (count) => {
+        events.push(count);
+      });
+      const result1 = await connection.increment(amount);
+      const result2 = await connection.increment(amount * 2);
+      await connection.dispose();
+      c.state.messages.push(
+        `Connected to counter, incremented by ${amount} and ${amount * 2}, results: ${result1}, ${result2}, events: ${JSON.stringify(events)}`
+      );
+      return { result1, result2, events };
+    },
+    // Get all messages from this actor's state
+    getMessages: (c) => {
+      return c.state.messages;
+    },
+    // Clear messages
+    clearMessages: (c) => {
+      c.state.messages = [];
+    }
+  }
+});
+
+// fixtures/driver-test-suite/kv.ts
+var kvActor = actor({
+  actions: {
+    putText: async (c, key, value) => {
+      await c.kv.put(key, value);
+      return true;
+    },
+    getText: async (c, key) => {
+      return await c.kv.get(key);
+    },
+    listText: async (c, prefix) => {
+      const results = await c.kv.list(prefix, { keyType: "text" });
+      return results.map(([key, value]) => ({
+        key,
+        value
+      }));
+    },
+    roundtripArrayBuffer: async (c, key, values) => {
+      const buffer = new Uint8Array(values).buffer;
+      await c.kv.put(key, buffer, { type: "arrayBuffer" });
+      const result = await c.kv.get(key, { type: "arrayBuffer" });
+      if (!result) {
+        return null;
+      }
+      return Array.from(new Uint8Array(result));
+    }
+  }
+});
+
+// fixtures/driver-test-suite/large-payloads.ts
+var largePayloadActor = actor({
+  state: {},
+  actions: {
+    /**
+     * Accepts a large request payload and returns its size
+     */
+    processLargeRequest: (c, data) => {
+      return {
+        itemCount: data.items.length,
+        firstItem: data.items[0],
+        lastItem: data.items[data.items.length - 1]
+      };
+    },
+    /**
+     * Returns a large response payload
+     */
+    getLargeResponse: (c, itemCount) => {
+      const items = [];
+      for (let i = 0; i < itemCount; i++) {
+        items.push(`Item ${i} with some additional text to increase size`);
+      }
+      return { items };
+    },
+    /**
+     * Echo back the request data
+     */
+    echo: (c, data) => {
+      return data;
+    }
+  }
+});
+var largePayloadConnActor = actor({
+  state: {},
+  connState: {
+    lastRequestSize: 0
+  },
+  actions: {
+    /**
+     * Accepts a large request payload and returns its size
+     */
+    processLargeRequest: (c, data) => {
+      c.conn.state.lastRequestSize = data.items.length;
+      return {
+        itemCount: data.items.length,
+        firstItem: data.items[0],
+        lastItem: data.items[data.items.length - 1]
+      };
+    },
+    /**
+     * Returns a large response payload
+     */
+    getLargeResponse: (c, itemCount) => {
+      const items = [];
+      for (let i = 0; i < itemCount; i++) {
+        items.push(`Item ${i} with some additional text to increase size`);
+      }
+      return { items };
+    },
+    /**
+     * Echo back the request data
+     */
+    echo: (c, data) => {
+      return data;
+    },
+    /**
+     * Get the last request size
+     */
+    getLastRequestSize: (c) => {
+      return c.conn.state.lastRequestSize;
+    }
+  }
+});
+
+// fixtures/driver-test-suite/lifecycle.ts
+var counterWithLifecycle = actor({
+  state: {
+    count: 0,
+    events: []
+  },
+  createConnState: (c, params) => ({
+    joinTime: Date.now()
+  }),
+  onWake: (c) => {
+    c.state.events.push("onWake");
+  },
+  onBeforeConnect: (c, params) => {
+    if (params == null ? void 0 : params.trackLifecycle) c.state.events.push("onBeforeConnect");
+  },
+  onConnect: (c, conn) => {
+    var _a;
+    if ((_a = conn.params) == null ? void 0 : _a.trackLifecycle) c.state.events.push("onConnect");
+  },
+  onDisconnect: (c, conn) => {
+    var _a;
+    if ((_a = conn.params) == null ? void 0 : _a.trackLifecycle) c.state.events.push("onDisconnect");
+  },
+  actions: {
+    getEvents: (c) => {
+      return c.state.events;
+    },
+    increment: (c, x) => {
+      c.state.count += x;
+      return c.state.count;
+    }
+  }
+});
+
+// fixtures/driver-test-suite/metadata.ts
+var metadataActor = actor({
+  state: {
+    lastMetadata: null,
+    actorName: "",
+    // Store tags and region in state for testing since they may not be
+    // available in the context in all environments
+    storedTags: {},
+    storedRegion: null
+  },
+  onWake: (c) => {
+    c.state.actorName = c.name;
+  },
+  actions: {
+    // Set up test tags - this will be called by tests to simulate tags
+    setupTestTags: (c, tags) => {
+      c.state.storedTags = tags;
+      return tags;
+    },
+    // Set up test region - this will be called by tests to simulate region
+    setupTestRegion: (c, region) => {
+      c.state.storedRegion = region;
+      return region;
+    },
+    // Get all available metadata
+    getMetadata: (c) => {
+      const metadata = {
+        name: c.name,
+        tags: c.state.storedTags,
+        region: c.state.storedRegion
+      };
+      c.state.lastMetadata = metadata;
+      return metadata;
+    },
+    // Get the actor name
+    getActorName: (c) => {
+      return c.name;
+    },
+    // Get a specific tag by key
+    getTag: (c, key) => {
+      return c.state.storedTags[key] || null;
+    },
+    // Get all tags
+    getTags: (c) => {
+      return c.state.storedTags;
+    },
+    // Get the region
+    getRegion: (c) => {
+      return c.state.storedRegion;
+    },
+    // Get the stored actor name (from onWake)
+    getStoredActorName: (c) => {
+      return c.state.actorName;
+    },
+    // Get last retrieved metadata
+    getLastMetadata: (c) => {
+      return c.state.lastMetadata;
+    }
+  }
+});
+
+// fixtures/driver-test-suite/raw-http.ts
+import { Hono } from "hono";
+var rawHttpActor = actor({
+  state: {
+    requestCount: 0
+  },
+  onRequest(ctx, request) {
+    const url = new URL(request.url);
+    const method = request.method;
+    ctx.state.requestCount++;
+    if (url.pathname === "/api/hello") {
+      return new Response(
+        JSON.stringify({ message: "Hello from actor!" }),
+        {
+          headers: { "Content-Type": "application/json" }
+        }
+      );
+    }
+    if (url.pathname === "/api/echo" && method === "POST") {
+      return new Response(request.body, {
+        headers: request.headers
+      });
+    }
+    if (url.pathname === "/api/state") {
+      return new Response(
+        JSON.stringify({
+          requestCount: ctx.state.requestCount
+        }),
+        {
+          headers: { "Content-Type": "application/json" }
+        }
+      );
+    }
+    if (url.pathname === "/api/headers") {
+      const headers = {};
+      request.headers.forEach((value, key) => {
+        headers[key] = value;
+      });
+      return new Response(JSON.stringify(headers), {
+        headers: { "Content-Type": "application/json" }
+      });
+    }
+    return new Response("Not Found", { status: 404 });
+  },
+  actions: {}
+});
+var rawHttpNoHandlerActor = actor({
+  actions: {}
+});
+var rawHttpVoidReturnActor = actor({
+  onRequest(ctx, request) {
+    return void 0;
+  },
+  actions: {}
+});
+var rawHttpHonoActor = actor({
+  createVars() {
+    const router = new Hono();
+    router.get(
+      "/",
+      (c) => c.json({ message: "Welcome to Hono actor!" })
+    );
+    router.get(
+      "/users",
+      (c) => c.json([
+        { id: 1, name: "Alice" },
+        { id: 2, name: "Bob" }
+      ])
+    );
+    router.get("/users/:id", (c) => {
+      const id = c.req.param("id");
+      return c.json({
+        id: parseInt(id),
+        name: id === "1" ? "Alice" : "Bob"
+      });
+    });
+    router.post("/users", async (c) => {
+      const body = await c.req.json();
+      return c.json({ id: 3, ...body }, 201);
+    });
+    router.put("/users/:id", async (c) => {
+      const id = c.req.param("id");
+      const body = await c.req.json();
+      return c.json({ id: parseInt(id), ...body });
+    });
+    router.delete("/users/:id", (c) => {
+      const id = c.req.param("id");
+      return c.json({ message: `User ${id} deleted` });
+    });
+    return { router };
+  },
+  onRequest(ctx, request) {
+    return ctx.vars.router.fetch(request);
+  },
+  actions: {}
+});
+
+// fixtures/driver-test-suite/raw-http-request-properties.ts
+var rawHttpRequestPropertiesActor = actor({
+  actions: {},
+  onRequest(ctx, request) {
+    const url = new URL(request.url);
+    const method = request.method;
+    const headers = {};
+    request.headers.forEach((value, key) => {
+      headers[key] = value;
+    });
+    const handleBody = async () => {
+      if (!request.body) {
+        return null;
+      }
+      const contentType = request.headers.get("content-type") || "";
+      try {
+        if (contentType.includes("application/json")) {
+          const text = await request.text();
+          return text ? JSON.parse(text) : null;
+        } else {
+          const text = await request.text();
+          return text || null;
+        }
+      } catch (error) {
+        return null;
+      }
+    };
+    if (method === "HEAD") {
+      return new Response(null, {
+        status: 200
+      });
+    }
+    if (method === "OPTIONS") {
+      return new Response(null, {
+        status: 204
+      });
+    }
+    return handleBody().then((body) => {
+      const responseData = {
+        // URL properties
+        url: request.url,
+        pathname: url.pathname,
+        search: url.search,
+        searchParams: Object.fromEntries(url.searchParams.entries()),
+        hash: url.hash,
+        // Method
+        method: request.method,
+        // Headers
+        headers,
+        // Body
+        body,
+        bodyText: typeof body === "string" ? body : body === null && request.body !== null ? "" : null,
+        // Additional properties that might be available
+        // Note: Some properties like cache, credentials, mode, etc.
+        // might not be available in all environments
+        cache: request.cache || null,
+        credentials: request.credentials || null,
+        mode: request.mode || null,
+        redirect: request.redirect || null,
+        referrer: request.referrer || null
+      };
+      return new Response(JSON.stringify(responseData), {
+        headers: { "Content-Type": "application/json" }
+      });
+    });
+  }
+});
+
+// fixtures/driver-test-suite/raw-websocket.ts
+var rawWebSocketActor = actor({
+  state: {
+    connectionCount: 0,
+    messageCount: 0
+  },
+  onWebSocket(ctx, websocket) {
+    ctx.state.connectionCount = ctx.state.connectionCount + 1;
+    console.log(
+      `[ACTOR] New connection, count: ${ctx.state.connectionCount}`
+    );
+    websocket.send(
+      JSON.stringify({
+        type: "welcome",
+        connectionCount: ctx.state.connectionCount
+      })
+    );
+    console.log("[ACTOR] Sent welcome message");
+    websocket.addEventListener("message", (event) => {
+      var _a;
+      ctx.state.messageCount = ctx.state.messageCount + 1;
+      console.log(
+        `[ACTOR] Message received, total count: ${ctx.state.messageCount}, data:`,
+        event.data
+      );
+      const data = event.data;
+      if (typeof data === "string") {
+        try {
+          const parsed = JSON.parse(data);
+          if (parsed.type === "ping") {
+            websocket.send(
+              JSON.stringify({
+                type: "pong",
+                timestamp: Date.now()
+              })
+            );
+          } else if (parsed.type === "getStats") {
+            console.log(
+              `[ACTOR] Sending stats - connections: ${ctx.state.connectionCount}, messages: ${ctx.state.messageCount}`
+            );
+            websocket.send(
+              JSON.stringify({
+                type: "stats",
+                connectionCount: ctx.state.connectionCount,
+                messageCount: ctx.state.messageCount
+              })
+            );
+          } else if (parsed.type === "getRequestInfo") {
+            const url = ((_a = ctx.request) == null ? void 0 : _a.url) || "ws://actor/websocket";
+            const urlObj = new URL(url);
+            websocket.send(
+              JSON.stringify({
+                type: "requestInfo",
+                url,
+                pathname: urlObj.pathname,
+                search: urlObj.search
+              })
+            );
+          } else {
+            websocket.send(data);
+          }
+        } catch {
+          websocket.send(data);
+        }
+      } else {
+        websocket.send(data);
+      }
+    });
+    websocket.addEventListener("close", () => {
+      ctx.state.connectionCount = ctx.state.connectionCount - 1;
+      console.log(
+        `[ACTOR] Connection closed, count: ${ctx.state.connectionCount}`
+      );
+    });
+  },
+  actions: {
+    getStats(ctx) {
+      return {
+        connectionCount: ctx.state.connectionCount,
+        messageCount: ctx.state.messageCount
+      };
+    }
+  }
+});
+var rawWebSocketBinaryActor = actor({
+  onWebSocket(ctx, websocket) {
+    websocket.addEventListener("message", (event) => {
+      const data = event.data;
+      if (data instanceof ArrayBuffer || data instanceof Uint8Array) {
+        const bytes = new Uint8Array(data);
+        const reversed = new Uint8Array(bytes.length);
+        for (let i = 0; i < bytes.length; i++) {
+          reversed[i] = bytes[bytes.length - 1 - i];
+        }
+        websocket.send(reversed);
+      }
+    });
+  },
+  actions: {}
+});
+
+// fixtures/driver-test-suite/request-access.ts
+var requestAccessActor = actor({
+  state: {
+    // Track request info from different hooks
+    onBeforeConnectRequest: {
+      hasRequest: false,
+      requestUrl: null,
+      requestMethod: null,
+      requestHeaders: {}
+    },
+    createConnStateRequest: {
+      hasRequest: false,
+      requestUrl: null,
+      requestMethod: null,
+      requestHeaders: {}
+    },
+    onRequestRequest: {
+      hasRequest: false,
+      requestUrl: null,
+      requestMethod: null,
+      requestHeaders: {}
+    },
+    onWebSocketRequest: {
+      hasRequest: false,
+      requestUrl: null,
+      requestMethod: null,
+      requestHeaders: {}
+    }
+  },
+  createConnState: (c, params) => {
+    let requestInfo = null;
+    if ((params == null ? void 0 : params.trackRequest) && c.request) {
+      const headers = {};
+      c.request.headers.forEach((value, key) => {
+        headers[key] = value;
+      });
+      requestInfo = {
+        hasRequest: true,
+        requestUrl: c.request.url,
+        requestMethod: c.request.method,
+        requestHeaders: headers
+      };
+    }
+    return {
+      trackRequest: (params == null ? void 0 : params.trackRequest) || false,
+      requestInfo
+    };
+  },
+  onConnect: (c, conn) => {
+    if (conn.state.requestInfo) {
+      c.state.createConnStateRequest = conn.state.requestInfo;
+    }
+  },
+  onBeforeConnect: (c, params) => {
+    if (params == null ? void 0 : params.trackRequest) {
+      if (c.request) {
+        c.state.onBeforeConnectRequest.hasRequest = true;
+        c.state.onBeforeConnectRequest.requestUrl = c.request.url;
+        c.state.onBeforeConnectRequest.requestMethod = c.request.method;
+        const headers = {};
+        c.request.headers.forEach((value, key) => {
+          headers[key] = value;
+        });
+        c.state.onBeforeConnectRequest.requestHeaders = headers;
+      } else {
+        c.state.onBeforeConnectRequest.hasRequest = false;
+      }
+    }
+  },
+  onRequest: (c, request) => {
+    c.state.onRequestRequest.hasRequest = true;
+    c.state.onRequestRequest.requestUrl = request.url;
+    c.state.onRequestRequest.requestMethod = request.method;
+    const headers = {};
+    request.headers.forEach((value, key) => {
+      headers[key] = value;
+    });
+    c.state.onRequestRequest.requestHeaders = headers;
+    return new Response(
+      JSON.stringify({
+        hasRequest: true,
+        requestUrl: request.url,
+        requestMethod: request.method,
+        requestHeaders: headers
+      }),
+      {
+        status: 200,
+        headers: { "Content-Type": "application/json" }
+      }
+    );
+  },
+  onWebSocket: (c, websocket) => {
+    if (!c.request) throw "Missing request";
+    c.state.onWebSocketRequest.hasRequest = true;
+    c.state.onWebSocketRequest.requestUrl = c.request.url;
+    c.state.onWebSocketRequest.requestMethod = c.request.method;
+    const headers = {};
+    c.request.headers.forEach((value, key) => {
+      headers[key] = value;
+    });
+    c.state.onWebSocketRequest.requestHeaders = headers;
+    websocket.send(
+      JSON.stringify({
+        hasRequest: true,
+        requestUrl: c.request.url,
+        requestMethod: c.request.method,
+        requestHeaders: headers
+      })
+    );
+    websocket.addEventListener("message", (event) => {
+      websocket.send(event.data);
+    });
+  },
+  actions: {
+    getRequestInfo: (c) => {
+      return {
+        onBeforeConnect: c.state.onBeforeConnectRequest,
+        createConnState: c.state.createConnStateRequest,
+        onRequest: c.state.onRequestRequest,
+        onWebSocket: c.state.onWebSocketRequest
+      };
+    }
+  }
+});
+
+// fixtures/driver-test-suite/reject-connection.ts
+var rejectConnectionActor = actor({
+  onBeforeConnect: async (_c, params) => {
+    if (params == null ? void 0 : params.reject) {
+      await new Promise((resolve) => setTimeout(resolve, 500));
+      throw new UserError("Rejected connection", {
+        code: "rejected"
+      });
+    }
+  },
+  actions: {
+    ping: () => "pong"
+  }
+});
+
+// fixtures/driver-test-suite/scheduled.ts
+var scheduled = actor({
+  state: {
+    lastRun: 0,
+    scheduledCount: 0,
+    taskHistory: []
+  },
+  actions: {
+    // Schedule using 'at' with specific timestamp
+    scheduleTaskAt: (c, timestamp) => {
+      c.schedule.at(timestamp, "onScheduledTask");
+      return timestamp;
+    },
+    // Schedule using 'after' with delay
+    scheduleTaskAfter: (c, delayMs) => {
+      c.schedule.after(delayMs, "onScheduledTask");
+      return Date.now() + delayMs;
+    },
+    // Schedule with a task ID for ordering tests
+    scheduleTaskAfterWithId: (c, taskId, delayMs) => {
+      c.schedule.after(delayMs, "onScheduledTaskWithId", taskId);
+      return { taskId, scheduledFor: Date.now() + delayMs };
+    },
+    // Original method for backward compatibility
+    scheduleTask: (c, delayMs) => {
+      const timestamp = Date.now() + delayMs;
+      c.schedule.at(timestamp, "onScheduledTask");
+      return timestamp;
+    },
+    // Getters for state
+    getLastRun: (c) => {
+      return c.state.lastRun;
+    },
+    getScheduledCount: (c) => {
+      return c.state.scheduledCount;
+    },
+    getTaskHistory: (c) => {
+      return c.state.taskHistory;
+    },
+    clearHistory: (c) => {
+      c.state.taskHistory = [];
+      c.state.scheduledCount = 0;
+      c.state.lastRun = 0;
+      return true;
+    },
+    // Scheduled task handlers
+    onScheduledTask: (c) => {
+      c.state.lastRun = Date.now();
+      c.state.scheduledCount++;
+      c.broadcast("scheduled", {
+        time: c.state.lastRun,
+        count: c.state.scheduledCount
+      });
+    },
+    onScheduledTaskWithId: (c, taskId) => {
+      c.state.lastRun = Date.now();
+      c.state.scheduledCount++;
+      c.state.taskHistory.push(taskId);
+      c.broadcast("scheduledWithId", {
+        taskId,
+        time: c.state.lastRun,
+        count: c.state.scheduledCount
+      });
+    }
+  }
+});
+
+// fixtures/driver-test-suite/vars.ts
+var staticVarActor = actor({
+  state: { value: 0 },
+  connState: { hello: "world" },
+  vars: { counter: 42, name: "test-actor" },
+  actions: {
+    getVars: (c) => {
+      return c.vars;
+    },
+    getName: (c) => {
+      return c.vars.name;
+    }
+  }
+});
+var nestedVarActor = actor({
+  state: { value: 0 },
+  connState: { hello: "world" },
+  vars: {
+    counter: 42,
+    nested: {
+      value: "original",
+      array: [1, 2, 3],
+      obj: { key: "value" }
+    }
+  },
+  actions: {
+    getVars: (c) => {
+      return c.vars;
+    },
+    modifyNested: (c) => {
+      c.vars.nested.value = "modified";
+      c.vars.nested.array.push(4);
+      c.vars.nested.obj.key = "new-value";
+      return c.vars;
+    }
+  }
+});
+var dynamicVarActor = actor({
+  state: { value: 0 },
+  connState: { hello: "world" },
+  createVars: () => {
+    return {
+      random: Math.random(),
+      computed: `Actor-${Math.floor(Math.random() * 1e3)}`
+    };
+  },
+  actions: {
+    getVars: (c) => {
+      return c.vars;
+    }
+  }
+});
+var uniqueVarActor = actor({
+  state: { value: 0 },
+  connState: { hello: "world" },
+  createVars: () => {
+    return {
+      id: Math.floor(Math.random() * 1e6)
+    };
+  },
+  actions: {
+    getVars: (c) => {
+      return c.vars;
+    }
+  }
+});
+var driverCtxActor = actor({
+  state: { value: 0 },
+  connState: { hello: "world" },
+  createVars: (c, driverCtx) => {
+    return {
+      hasDriverCtx: Boolean(driverCtx == null ? void 0 : driverCtx.isTest)
+    };
+  },
+  actions: {
+    getVars: (c) => {
+      return c.vars;
+    }
+  }
+});
+
+// fixtures/driver-test-suite/registry.ts
+var registry = setup({
+  use: {
+    // From counter.ts
+    counter,
+    // From counter-conn.ts
+    counterConn,
+    // From lifecycle.ts
+    counterWithLifecycle,
+    // From scheduled.ts
+    scheduled,
+    // From sleep.ts
+    sleep,
+    sleepWithLongRpc,
+    sleepWithRawHttp,
+    sleepWithRawWebSocket,
+    sleepWithNoSleepOption,
+    // From error-handling.ts
+    errorHandlingActor,
+    customTimeoutActor,
+    // From inline-client.ts
+    inlineClientActor,
+    // From kv.ts
+    kvActor,
+    // From action-inputs.ts
+    inputActor,
+    // From action-timeout.ts
+    shortTimeoutActor,
+    longTimeoutActor,
+    defaultTimeoutActor,
+    syncTimeoutActor,
+    // From action-types.ts
+    syncActionActor,
+    asyncActionActor,
+    promiseActor,
+    // From conn-params.ts
+    counterWithParams,
+    // From conn-state.ts
+    connStateActor,
+    // From metadata.ts
+    metadataActor,
+    // From vars.ts
+    staticVarActor,
+    nestedVarActor,
+    dynamicVarActor,
+    uniqueVarActor,
+    driverCtxActor,
+    // From raw-http.ts
+    rawHttpActor,
+    rawHttpNoHandlerActor,
+    rawHttpVoidReturnActor,
+    rawHttpHonoActor,
+    // From raw-http-request-properties.ts
+    rawHttpRequestPropertiesActor,
+    // From raw-websocket.ts
+    rawWebSocketActor,
+    rawWebSocketBinaryActor,
+    // From reject-connection.ts
+    rejectConnectionActor,
+    // From request-access.ts
+    requestAccessActor,
+    // From actor-onstatechange.ts
+    onStateChangeActor,
+    // From destroy.ts
+    destroyActor,
+    destroyObserver,
+    // From hibernation.ts
+    hibernationActor,
+    // From large-payloads.ts
+    largePayloadActor,
+    largePayloadConnActor
+  }
+});
+
+// src/serve-test-suite/mod.ts
+async function getPort() {
+  const MIN_PORT = 1e4;
+  const MAX_PORT = 65535;
+  const getRandomPort = () => Math.floor(Math.random() * (MAX_PORT - MIN_PORT + 1)) + MIN_PORT;
+  let port = getRandomPort();
+  let maxAttempts = 10;
+  while (maxAttempts > 0) {
+    try {
+      const server = await new Promise((resolve, reject) => {
+        const server2 = createServer();
+        server2.once("error", (err) => {
+          if (err.code === "EADDRINUSE") {
+            reject(new Error(`Port ${port} is in use`));
+          } else {
+            reject(err);
+          }
+        });
+        server2.once("listening", () => {
+          resolve(server2);
+        });
+        server2.listen(port);
+      });
+      await new Promise((resolve) => {
+        server.close(() => resolve());
+      });
+      return port;
+    } catch {
+      maxAttempts--;
+      if (maxAttempts <= 0) {
+        break;
+      }
+      port = getRandomPort();
+    }
+  }
+  throw new Error("Could not find an available port after multiple attempts");
+}
+async function serveTestSuite() {
+  var _a;
+  registry.config.test = { ...registry.config.test, enabled: true };
+  registry.config.inspector = {
+    enabled: true,
+    token: () => "token"
+  };
+  const port = await getPort();
+  registry.config.managerPort = port;
+  registry.config.serverless = {
+    ...registry.config.serverless,
+    publicEndpoint: `http://127.0.0.1:${port}`
+  };
+  const driver = await createFileSystemOrMemoryDriver(
+    true,
+    `/tmp/rivetkit-test-suite-${crypto.randomUUID()}`
+  );
+  registry.config.driver = driver;
+  let upgradeWebSocket;
+  const parsedConfig = registry.parseConfig();
+  const managerDriver = (_a = driver.manager) == null ? void 0 : _a.call(driver, parsedConfig);
+  invariant(managerDriver, "missing manager driver");
+  const { router } = buildManagerRouter(
+    parsedConfig,
+    managerDriver,
+    () => upgradeWebSocket
+  );
+  const nodeWebSocket = createNodeWebSocket({ app: router });
+  upgradeWebSocket = nodeWebSocket.upgradeWebSocket;
+  managerDriver.setGetUpgradeWebSocket(() => upgradeWebSocket);
+  const server = honoServe({
+    fetch: router.fetch,
+    hostname: "127.0.0.1",
+    port
+  });
+  invariant(
+    nodeWebSocket.injectWebSocket !== void 0,
+    "should have injectWebSocket"
+  );
+  nodeWebSocket.injectWebSocket(server);
+  const endpoint = `http://127.0.0.1:${port}`;
+  logger().info({ msg: "test suite server listening", port });
+  return {
+    endpoint,
+    namespace: "default",
+    runnerName: "default",
+    close: async () => {
+      await new Promise((resolve) => server.close(() => resolve(void 0)));
+    }
+  };
+}
+async function runCli() {
+  const result = await serveTestSuite();
+  process.stdout.write(
+    `${JSON.stringify({
+      endpoint: result.endpoint,
+      namespace: result.namespace,
+      runnerName: result.runnerName
+    })}
+`
+  );
+  const shutdown = async () => {
+    await result.close();
+    process.exit(0);
+  };
+  process.on("SIGINT", shutdown);
+  process.on("SIGTERM", shutdown);
+}
+var mainPath = process.argv[1];
+if (mainPath && mainPath === fileURLToPath(import.meta.url)) {
+  runCli().catch((err) => {
+    logger().error({ msg: "serve-test-suite failed", error: err });
+    process.exit(1);
+  });
+}
+export {
+  serveTestSuite
+};
+//# sourceMappingURL=mod.js.map