rivetkit 2.0.27 → 2.0.29-rc.1

package/dist/tsup/chunk-SE37OCA2.cjs

@@ -0,0 +1,891 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) { newObj[key] = obj[key]; } } } newObj.default = obj; return newObj; } } function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; } function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+var _chunkJ74MGKP5cjs = require('./chunk-J74MGKP5.cjs');
+
+
+
+
+
+var _chunkAJ36VBHLcjs = require('./chunk-AJ36VBHL.cjs');
+
+// src/registry/run-config.ts
+var _zod = require('zod'); var _zod2 = _interopRequireDefault(_zod);
+
+// src/drivers/engine/config.ts
+
+
+// src/client/config.ts
+
+var ClientConfigSchema = _zod2.default.object({
+  /** Endpoint to connect to for Rivet Engine or RivetKit manager API. */
+  endpoint: _zod2.default.string().optional().transform(
+    (x) => _nullishCoalesce(_nullishCoalesce(x, () => ( _chunkAJ36VBHLcjs.getEnvUniversal.call(void 0, "RIVET_ENGINE"))), () => ( _chunkAJ36VBHLcjs.getEnvUniversal.call(void 0, "RIVET_ENDPOINT")))
+  ),
+  /** Token to use to authenticate with the API. */
+  token: _zod2.default.string().optional().transform((x) => _nullishCoalesce(x, () => ( _chunkAJ36VBHLcjs.getEnvUniversal.call(void 0, "RIVET_TOKEN")))),
+  /** Namespace to connect to. */
+  namespace: _zod2.default.string().default(() => _nullishCoalesce(_chunkAJ36VBHLcjs.getEnvUniversal.call(void 0, "RIVET_NAMESPACE"), () => ( "default"))),
+  /** Name of the runner. This is used to group together runners in to different pools. */
+  runnerName: _zod2.default.string().default(() => _nullishCoalesce(_chunkAJ36VBHLcjs.getEnvUniversal.call(void 0, "RIVET_RUNNER"), () => ( "default"))),
+  encoding: _chunkJ74MGKP5cjs.EncodingSchema.default("bare"),
+  headers: _zod2.default.record(_zod2.default.string(), _zod2.default.string()).optional().default(() => ({})),
+  // See RunConfig.getUpgradeWebSocket
+  getUpgradeWebSocket: _zod2.default.custom().optional(),
+  /** Whether to automatically perform health checks when the client is created. */
+  disableMetadataLookup: _zod2.default.boolean().optional().default(false)
+});
+
+// src/drivers/engine/config.ts
+var EngineConfigSchemaBase = _zod.z.object({
+  /** Unique key for this runner. Runners connecting a given key will replace any other runner connected with the same key. */
+  runnerKey: _zod.z.string().optional().transform((x) => _nullishCoalesce(x, () => ( _chunkAJ36VBHLcjs.getEnvUniversal.call(void 0, "RIVET_RUNNER_KEY")))),
+  /** How many actors this runner can run. */
+  totalSlots: _zod.z.number().default(1e5)
+}).merge(ClientConfigSchema);
+var EngingConfigSchema = EngineConfigSchemaBase.default(
+  () => EngineConfigSchemaBase.parse({})
+);
+
+// src/inspector/config.ts
+
+var defaultTokenFn = () => {
+  const envToken = _chunkAJ36VBHLcjs.getEnvUniversal.call(void 0, "RIVETKIT_INSPECTOR_TOKEN");
+  if (envToken) {
+    return envToken;
+  }
+  return "";
+};
+var defaultEnabled = () => {
+  return _chunkAJ36VBHLcjs.getEnvUniversal.call(void 0, "NODE_ENV") !== "production" || !_chunkAJ36VBHLcjs.getEnvUniversal.call(void 0, "RIVETKIT_INSPECTOR_DISABLE");
+};
+var InspectorConfigSchema = _zod.z.object({
+  enabled: _zod.z.boolean().or(
+    _zod.z.object({
+      actor: _zod.z.boolean().optional().default(true),
+      manager: _zod.z.boolean().optional().default(true)
+    })
+  ).optional().default(defaultEnabled),
+  /**
+   * Token used to access the Inspector.
+   */
+  token: _zod.z.custom().optional().default(() => defaultTokenFn),
+  /**
+   * Default RivetKit server endpoint for Rivet Inspector to connect to. This should be the same endpoint as what you use for your Rivet client to connect to RivetKit.
+   *
+   * This is a convenience property just for printing out the inspector URL.
+   */
+  defaultEndpoint: _zod.z.string().optional()
+}).optional().default(() => ({
+  enabled: defaultEnabled(),
+  token: defaultTokenFn
+}));
+
+// src/registry/run-config.ts
+var DriverConfigSchema = _zod.z.object({
+  /** Machine-readable name to identify this driver by. */
+  name: _zod.z.string(),
+  manager: _zod.z.custom(),
+  actor: _zod.z.custom()
+});
+var RunnerConfigSchemaUnmerged = _zod.z.object({
+  driver: DriverConfigSchema.optional(),
+  /** @experimental */
+  maxIncomingMessageSize: _zod.z.number().optional().default(65536),
+  /** @experimental */
+  inspector: InspectorConfigSchema,
+  /** @experimental */
+  disableDefaultServer: _zod.z.boolean().optional().default(false),
+  /** @experimental */
+  defaultServerPort: _zod.z.number().default(6420),
+  /** @experimental */
+  runEngine: _zod.z.boolean().optional().default(() => _chunkAJ36VBHLcjs.getEnvUniversal.call(void 0, "RIVET_RUN_ENGINE") === "1"),
+  /** @experimental */
+  runEngineVersion: _zod.z.string().optional().default(
+    () => _nullishCoalesce(_chunkAJ36VBHLcjs.getEnvUniversal.call(void 0, "RIVET_RUN_ENGINE_VERSION"), () => ( _chunkAJ36VBHLcjs.VERSION))
+  ),
+  /** @experimental */
+  overrideServerAddress: _zod.z.string().optional(),
+  /** @experimental */
+  disableActorDriver: _zod.z.boolean().optional().default(false),
+  /**
+   * @experimental
+   *
+   * Whether to run runners normally or have them managed
+   * serverlessly (by the Rivet Engine for example).
+   */
+  runnerKind: _zod.z.enum(["serverless", "normal"]).optional().default(
+    () => _chunkAJ36VBHLcjs.getEnvUniversal.call(void 0, "RIVET_RUNNER_KIND") === "serverless" ? "serverless" : "normal"
+  ),
+  totalSlots: _zod.z.number().optional(),
+  /**
+   * @experimental
+   *
+   * Base path for the router. This is used to prefix all routes.
+   * For example, if the base path is `/api`, then the route `/actors` will be
+   * available at `/api/actors`.
+   */
+  basePath: _zod.z.string().optional().default("/"),
+  /**
+   * @experimental
+   *
+   * Disable welcome message.
+   * */
+  noWelcome: _zod.z.boolean().optional().default(false),
+  /**
+   * @experimental
+   * */
+  logging: _zod.z.object({
+    baseLogger: _zod.z.custom().optional(),
+    level: _chunkAJ36VBHLcjs.LogLevelSchema.optional()
+  }).optional().default(() => ({})),
+  /**
+   * @experimental
+   *
+   * Automatically configure serverless runners in the engine.
+   * Can only be used when runnerKind is "serverless".
+   * If true, uses default configuration. Can also provide custom configuration.
+   */
+  autoConfigureServerless: _zod.z.union([
+    _zod.z.boolean(),
+    _zod.z.object({
+      url: _zod.z.string().optional(),
+      headers: _zod.z.record(_zod.z.string(), _zod.z.string()).optional(),
+      maxRunners: _zod.z.number().optional(),
+      minRunners: _zod.z.number().optional(),
+      requestLifespan: _zod.z.number().optional(),
+      runnersMargin: _zod.z.number().optional(),
+      slotsPerRunner: _zod.z.number().optional(),
+      metadata: _zod.z.record(_zod.z.string(), _zod.z.unknown()).optional()
+    })
+  ]).optional(),
+  // This is a function to allow for lazy configuration of upgradeWebSocket on the
+  // fly. This is required since the dependencies that upgradeWebSocket
+  // (specifically Node.js) can sometimes only be specified after the router is
+  // created or must be imported async using `await import(...)`
+  getUpgradeWebSocket: _zod.z.custom().optional()
+}).merge(EngingConfigSchema.removeDefault());
+var RunnerConfigSchemaBase = RunnerConfigSchemaUnmerged;
+var RunnerConfigSchema = RunnerConfigSchemaBase.default(
+  () => RunnerConfigSchemaBase.parse({})
+);
+
+// src/driver-helpers/utils.ts
+var _cborx = require('cbor-x'); var cbor = _interopRequireWildcard(_cborx);
+
+// src/actor/instance/kv.ts
+var KEYS = {
+  PERSIST_DATA: Uint8Array.from([1]),
+  CONN_PREFIX: Uint8Array.from([2]),
+  // Prefix for connection keys
+  INSPECTOR_TOKEN: Uint8Array.from([3])
+  // Inspector token key
+};
+function makeConnKey(connId) {
+  const encoder = new TextEncoder();
+  const connIdBytes = encoder.encode(connId);
+  const key = new Uint8Array(KEYS.CONN_PREFIX.length + connIdBytes.length);
+  key.set(KEYS.CONN_PREFIX, 0);
+  key.set(connIdBytes, KEYS.CONN_PREFIX.length);
+  return key;
+}
+
+// src/schemas/actor-persist/versioned.ts
+var _vbare = require('vbare');
+
+// dist/schemas/actor-persist/v1.ts
+var _lib = require('@bare-ts/lib'); var bare = _interopRequireWildcard(_lib); var bare2 = _interopRequireWildcard(_lib); var bare3 = _interopRequireWildcard(_lib);
+var config = /* @__PURE__ */ bare.Config({});
+function readPersistedSubscription(bc) {
+  return {
+    eventName: bare.readString(bc)
+  };
+}
+function writePersistedSubscription(bc, x) {
+  bare.writeString(bc, x.eventName);
+}
+function read0(bc) {
+  const len = bare.readUintSafe(bc);
+  if (len === 0) {
+    return [];
+  }
+  const result = [readPersistedSubscription(bc)];
+  for (let i = 1; i < len; i++) {
+    result[i] = readPersistedSubscription(bc);
+  }
+  return result;
+}
+function write0(bc, x) {
+  bare.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    writePersistedSubscription(bc, x[i]);
+  }
+}
+function readPersistedConnection(bc) {
+  return {
+    id: bare.readString(bc),
+    token: bare.readString(bc),
+    parameters: bare.readData(bc),
+    state: bare.readData(bc),
+    subscriptions: read0(bc),
+    lastSeen: bare.readU64(bc)
+  };
+}
+function writePersistedConnection(bc, x) {
+  bare.writeString(bc, x.id);
+  bare.writeString(bc, x.token);
+  bare.writeData(bc, x.parameters);
+  bare.writeData(bc, x.state);
+  write0(bc, x.subscriptions);
+  bare.writeU64(bc, x.lastSeen);
+}
+function read1(bc) {
+  return bare.readBool(bc) ? bare.readData(bc) : null;
+}
+function write1(bc, x) {
+  bare.writeBool(bc, x !== null);
+  if (x !== null) {
+    bare.writeData(bc, x);
+  }
+}
+function readGenericPersistedScheduleEvent(bc) {
+  return {
+    action: bare.readString(bc),
+    args: read1(bc)
+  };
+}
+function writeGenericPersistedScheduleEvent(bc, x) {
+  bare.writeString(bc, x.action);
+  write1(bc, x.args);
+}
+function readPersistedScheduleEventKind(bc) {
+  const offset = bc.offset;
+  const tag = bare.readU8(bc);
+  switch (tag) {
+    case 0:
+      return { tag: "GenericPersistedScheduleEvent", val: readGenericPersistedScheduleEvent(bc) };
+    default: {
+      bc.offset = offset;
+      throw new bare.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writePersistedScheduleEventKind(bc, x) {
+  switch (x.tag) {
+    case "GenericPersistedScheduleEvent": {
+      bare.writeU8(bc, 0);
+      writeGenericPersistedScheduleEvent(bc, x.val);
+      break;
+    }
+  }
+}
+function readPersistedScheduleEvent(bc) {
+  return {
+    eventId: bare.readString(bc),
+    timestamp: bare.readU64(bc),
+    kind: readPersistedScheduleEventKind(bc)
+  };
+}
+function writePersistedScheduleEvent(bc, x) {
+  bare.writeString(bc, x.eventId);
+  bare.writeU64(bc, x.timestamp);
+  writePersistedScheduleEventKind(bc, x.kind);
+}
+function read2(bc) {
+  const len = bare.readUintSafe(bc);
+  if (len === 0) {
+    return [];
+  }
+  const result = [readPersistedConnection(bc)];
+  for (let i = 1; i < len; i++) {
+    result[i] = readPersistedConnection(bc);
+  }
+  return result;
+}
+function write2(bc, x) {
+  bare.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    writePersistedConnection(bc, x[i]);
+  }
+}
+function read3(bc) {
+  const len = bare.readUintSafe(bc);
+  if (len === 0) {
+    return [];
+  }
+  const result = [readPersistedScheduleEvent(bc)];
+  for (let i = 1; i < len; i++) {
+    result[i] = readPersistedScheduleEvent(bc);
+  }
+  return result;
+}
+function write3(bc, x) {
+  bare.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    writePersistedScheduleEvent(bc, x[i]);
+  }
+}
+function readPersistedActor(bc) {
+  return {
+    input: read1(bc),
+    hasInitialized: bare.readBool(bc),
+    state: bare.readData(bc),
+    connections: read2(bc),
+    scheduledEvents: read3(bc)
+  };
+}
+function writePersistedActor(bc, x) {
+  write1(bc, x.input);
+  bare.writeBool(bc, x.hasInitialized);
+  bare.writeData(bc, x.state);
+  write2(bc, x.connections);
+  write3(bc, x.scheduledEvents);
+}
+function encodePersistedActor(x) {
+  const bc = new bare.ByteCursor(
+    new Uint8Array(config.initialBufferLength),
+    config
+  );
+  writePersistedActor(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodePersistedActor(bytes) {
+  const bc = new bare.ByteCursor(bytes, config);
+  const result = readPersistedActor(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+
+// dist/schemas/actor-persist/v2.ts
+
+var config2 = /* @__PURE__ */ bare2.Config({});
+function readPersistedSubscription2(bc) {
+  return {
+    eventName: bare2.readString(bc)
+  };
+}
+function writePersistedSubscription2(bc, x) {
+  bare2.writeString(bc, x.eventName);
+}
+function read02(bc) {
+  const len = bare2.readUintSafe(bc);
+  if (len === 0) {
+    return [];
+  }
+  const result = [readPersistedSubscription2(bc)];
+  for (let i = 1; i < len; i++) {
+    result[i] = readPersistedSubscription2(bc);
+  }
+  return result;
+}
+function write02(bc, x) {
+  bare2.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    writePersistedSubscription2(bc, x[i]);
+  }
+}
+function read12(bc) {
+  return bare2.readBool(bc) ? bare2.readData(bc) : null;
+}
+function write12(bc, x) {
+  bare2.writeBool(bc, x !== null);
+  if (x !== null) {
+    bare2.writeData(bc, x);
+  }
+}
+function readPersistedConnection2(bc) {
+  return {
+    id: bare2.readString(bc),
+    token: bare2.readString(bc),
+    parameters: bare2.readData(bc),
+    state: bare2.readData(bc),
+    subscriptions: read02(bc),
+    lastSeen: bare2.readI64(bc),
+    hibernatableRequestId: read12(bc)
+  };
+}
+function writePersistedConnection2(bc, x) {
+  bare2.writeString(bc, x.id);
+  bare2.writeString(bc, x.token);
+  bare2.writeData(bc, x.parameters);
+  bare2.writeData(bc, x.state);
+  write02(bc, x.subscriptions);
+  bare2.writeI64(bc, x.lastSeen);
+  write12(bc, x.hibernatableRequestId);
+}
+function readGenericPersistedScheduleEvent2(bc) {
+  return {
+    action: bare2.readString(bc),
+    args: read12(bc)
+  };
+}
+function writeGenericPersistedScheduleEvent2(bc, x) {
+  bare2.writeString(bc, x.action);
+  write12(bc, x.args);
+}
+function readPersistedScheduleEventKind2(bc) {
+  const offset = bc.offset;
+  const tag = bare2.readU8(bc);
+  switch (tag) {
+    case 0:
+      return { tag: "GenericPersistedScheduleEvent", val: readGenericPersistedScheduleEvent2(bc) };
+    default: {
+      bc.offset = offset;
+      throw new bare2.BareError(offset, "invalid tag");
+    }
+  }
+}
+function writePersistedScheduleEventKind2(bc, x) {
+  switch (x.tag) {
+    case "GenericPersistedScheduleEvent": {
+      bare2.writeU8(bc, 0);
+      writeGenericPersistedScheduleEvent2(bc, x.val);
+      break;
+    }
+  }
+}
+function readPersistedScheduleEvent2(bc) {
+  return {
+    eventId: bare2.readString(bc),
+    timestamp: bare2.readI64(bc),
+    kind: readPersistedScheduleEventKind2(bc)
+  };
+}
+function writePersistedScheduleEvent2(bc, x) {
+  bare2.writeString(bc, x.eventId);
+  bare2.writeI64(bc, x.timestamp);
+  writePersistedScheduleEventKind2(bc, x.kind);
+}
+function readPersistedHibernatableWebSocket(bc) {
+  return {
+    requestId: bare2.readData(bc),
+    lastSeenTimestamp: bare2.readI64(bc),
+    msgIndex: bare2.readI64(bc)
+  };
+}
+function writePersistedHibernatableWebSocket(bc, x) {
+  bare2.writeData(bc, x.requestId);
+  bare2.writeI64(bc, x.lastSeenTimestamp);
+  bare2.writeI64(bc, x.msgIndex);
+}
+function read22(bc) {
+  const len = bare2.readUintSafe(bc);
+  if (len === 0) {
+    return [];
+  }
+  const result = [readPersistedConnection2(bc)];
+  for (let i = 1; i < len; i++) {
+    result[i] = readPersistedConnection2(bc);
+  }
+  return result;
+}
+function write22(bc, x) {
+  bare2.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    writePersistedConnection2(bc, x[i]);
+  }
+}
+function read32(bc) {
+  const len = bare2.readUintSafe(bc);
+  if (len === 0) {
+    return [];
+  }
+  const result = [readPersistedScheduleEvent2(bc)];
+  for (let i = 1; i < len; i++) {
+    result[i] = readPersistedScheduleEvent2(bc);
+  }
+  return result;
+}
+function write32(bc, x) {
+  bare2.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    writePersistedScheduleEvent2(bc, x[i]);
+  }
+}
+function read4(bc) {
+  const len = bare2.readUintSafe(bc);
+  if (len === 0) {
+    return [];
+  }
+  const result = [readPersistedHibernatableWebSocket(bc)];
+  for (let i = 1; i < len; i++) {
+    result[i] = readPersistedHibernatableWebSocket(bc);
+  }
+  return result;
+}
+function write4(bc, x) {
+  bare2.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    writePersistedHibernatableWebSocket(bc, x[i]);
+  }
+}
+function readPersistedActor2(bc) {
+  return {
+    input: read12(bc),
+    hasInitialized: bare2.readBool(bc),
+    state: bare2.readData(bc),
+    connections: read22(bc),
+    scheduledEvents: read32(bc),
+    hibernatableWebSockets: read4(bc)
+  };
+}
+function writePersistedActor2(bc, x) {
+  write12(bc, x.input);
+  bare2.writeBool(bc, x.hasInitialized);
+  bare2.writeData(bc, x.state);
+  write22(bc, x.connections);
+  write32(bc, x.scheduledEvents);
+  write4(bc, x.hibernatableWebSockets);
+}
+function encodePersistedActor2(x) {
+  const bc = new bare2.ByteCursor(
+    new Uint8Array(config2.initialBufferLength),
+    config2
+  );
+  writePersistedActor2(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodePersistedActor2(bytes) {
+  const bc = new bare2.ByteCursor(bytes, config2);
+  const result = readPersistedActor2(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare2.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+
+// dist/schemas/actor-persist/v3.ts
+
+var config3 = /* @__PURE__ */ bare3.Config({});
+function readGatewayId(bc) {
+  return bare3.readFixedData(bc, 4);
+}
+function writeGatewayId(bc, x) {
+  assert(x.byteLength === 4);
+  bare3.writeFixedData(bc, x);
+}
+function readRequestId(bc) {
+  return bare3.readFixedData(bc, 4);
+}
+function writeRequestId(bc, x) {
+  assert(x.byteLength === 4);
+  bare3.writeFixedData(bc, x);
+}
+function readCbor(bc) {
+  return bare3.readData(bc);
+}
+function writeCbor(bc, x) {
+  bare3.writeData(bc, x);
+}
+function readSubscription(bc) {
+  return {
+    eventName: bare3.readString(bc)
+  };
+}
+function writeSubscription(bc, x) {
+  bare3.writeString(bc, x.eventName);
+}
+function read03(bc) {
+  const len = bare3.readUintSafe(bc);
+  if (len === 0) {
+    return [];
+  }
+  const result = [readSubscription(bc)];
+  for (let i = 1; i < len; i++) {
+    result[i] = readSubscription(bc);
+  }
+  return result;
+}
+function write03(bc, x) {
+  bare3.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    writeSubscription(bc, x[i]);
+  }
+}
+function read13(bc) {
+  const len = bare3.readUintSafe(bc);
+  const result = /* @__PURE__ */ new Map();
+  for (let i = 0; i < len; i++) {
+    const offset = bc.offset;
+    const key = bare3.readString(bc);
+    if (result.has(key)) {
+      bc.offset = offset;
+      throw new bare3.BareError(offset, "duplicated key");
+    }
+    result.set(key, bare3.readString(bc));
+  }
+  return result;
+}
+function write13(bc, x) {
+  bare3.writeUintSafe(bc, x.size);
+  for (const kv of x) {
+    bare3.writeString(bc, kv[0]);
+    bare3.writeString(bc, kv[1]);
+  }
+}
+function readConn(bc) {
+  return {
+    id: bare3.readString(bc),
+    parameters: readCbor(bc),
+    state: readCbor(bc),
+    subscriptions: read03(bc),
+    gatewayId: readGatewayId(bc),
+    requestId: readRequestId(bc),
+    serverMessageIndex: bare3.readU16(bc),
+    clientMessageIndex: bare3.readU16(bc),
+    requestPath: bare3.readString(bc),
+    requestHeaders: read13(bc)
+  };
+}
+function writeConn(bc, x) {
+  bare3.writeString(bc, x.id);
+  writeCbor(bc, x.parameters);
+  writeCbor(bc, x.state);
+  write03(bc, x.subscriptions);
+  writeGatewayId(bc, x.gatewayId);
+  writeRequestId(bc, x.requestId);
+  bare3.writeU16(bc, x.serverMessageIndex);
+  bare3.writeU16(bc, x.clientMessageIndex);
+  bare3.writeString(bc, x.requestPath);
+  write13(bc, x.requestHeaders);
+}
+function encodeConn(x) {
+  const bc = new bare3.ByteCursor(
+    new Uint8Array(config3.initialBufferLength),
+    config3
+  );
+  writeConn(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeConn(bytes) {
+  const bc = new bare3.ByteCursor(bytes, config3);
+  const result = readConn(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare3.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+function read23(bc) {
+  return bare3.readBool(bc) ? readCbor(bc) : null;
+}
+function write23(bc, x) {
+  bare3.writeBool(bc, x !== null);
+  if (x !== null) {
+    writeCbor(bc, x);
+  }
+}
+function readScheduleEvent(bc) {
+  return {
+    eventId: bare3.readString(bc),
+    timestamp: bare3.readI64(bc),
+    action: bare3.readString(bc),
+    args: read23(bc)
+  };
+}
+function writeScheduleEvent(bc, x) {
+  bare3.writeString(bc, x.eventId);
+  bare3.writeI64(bc, x.timestamp);
+  bare3.writeString(bc, x.action);
+  write23(bc, x.args);
+}
+function read33(bc) {
+  const len = bare3.readUintSafe(bc);
+  if (len === 0) {
+    return [];
+  }
+  const result = [readScheduleEvent(bc)];
+  for (let i = 1; i < len; i++) {
+    result[i] = readScheduleEvent(bc);
+  }
+  return result;
+}
+function write33(bc, x) {
+  bare3.writeUintSafe(bc, x.length);
+  for (let i = 0; i < x.length; i++) {
+    writeScheduleEvent(bc, x[i]);
+  }
+}
+function readActor(bc) {
+  return {
+    input: read23(bc),
+    hasInitialized: bare3.readBool(bc),
+    state: readCbor(bc),
+    scheduledEvents: read33(bc)
+  };
+}
+function writeActor(bc, x) {
+  write23(bc, x.input);
+  bare3.writeBool(bc, x.hasInitialized);
+  writeCbor(bc, x.state);
+  write33(bc, x.scheduledEvents);
+}
+function encodeActor(x) {
+  const bc = new bare3.ByteCursor(
+    new Uint8Array(config3.initialBufferLength),
+    config3
+  );
+  writeActor(bc, x);
+  return new Uint8Array(bc.view.buffer, bc.view.byteOffset, bc.offset);
+}
+function decodeActor(bytes) {
+  const bc = new bare3.ByteCursor(bytes, config3);
+  const result = readActor(bc);
+  if (bc.offset < bc.view.byteLength) {
+    throw new bare3.BareError(bc.offset, "remaining bytes");
+  }
+  return result;
+}
+function assert(condition, message) {
+  if (!condition) throw new Error(_nullishCoalesce(message, () => ( "Assertion failed")));
+}
+
+// src/schemas/actor-persist/versioned.ts
+var CURRENT_VERSION = 3;
+var v1ToV2 = (v1Data) => ({
+  ...v1Data,
+  connections: v1Data.connections.map((conn) => ({
+    ...conn,
+    hibernatableRequestId: null
+  })),
+  hibernatableWebSockets: []
+});
+var v2ToV3 = (v2Data) => {
+  const scheduledEvents = v2Data.scheduledEvents.map(
+    (event) => {
+      if (event.kind.tag === "GenericPersistedScheduleEvent") {
+        return {
+          eventId: event.eventId,
+          timestamp: event.timestamp,
+          action: event.kind.val.action,
+          args: event.kind.val.args
+        };
+      }
+      throw new Error(`Unknown schedule event kind: ${event.kind.tag}`);
+    }
+  );
+  return {
+    input: v2Data.input,
+    hasInitialized: v2Data.hasInitialized,
+    state: v2Data.state,
+    scheduledEvents
+  };
+};
+var v3ToV2 = (v3Data) => {
+  const scheduledEvents = v3Data.scheduledEvents.map(
+    (event) => ({
+      eventId: event.eventId,
+      timestamp: event.timestamp,
+      kind: {
+        tag: "GenericPersistedScheduleEvent",
+        val: {
+          action: event.action,
+          args: event.args
+        }
+      }
+    })
+  );
+  return {
+    input: v3Data.input,
+    hasInitialized: v3Data.hasInitialized,
+    state: v3Data.state,
+    scheduledEvents,
+    connections: [],
+    hibernatableWebSockets: []
+  };
+};
+var v2ToV1 = (v2Data) => {
+  return {
+    input: v2Data.input,
+    hasInitialized: v2Data.hasInitialized,
+    state: v2Data.state,
+    scheduledEvents: v2Data.scheduledEvents,
+    connections: v2Data.connections.map((conn) => {
+      const { hibernatableRequestId, ...rest } = conn;
+      return rest;
+    })
+  };
+};
+var ACTOR_VERSIONED = _vbare.createVersionedDataHandler.call(void 0, {
+  deserializeVersion: (bytes, version) => {
+    switch (version) {
+      case 1:
+        return decodePersistedActor(bytes);
+      case 2:
+        return decodePersistedActor2(bytes);
+      case 3:
+        return decodeActor(bytes);
+      default:
+        throw new Error(`Unknown version ${version}`);
+    }
+  },
+  serializeVersion: (data, version) => {
+    switch (version) {
+      case 1:
+        return encodePersistedActor(data);
+      case 2:
+        return encodePersistedActor2(data);
+      case 3:
+        return encodeActor(data);
+      default:
+        throw new Error(`Unknown version ${version}`);
+    }
+  },
+  deserializeConverters: () => [v1ToV2, v2ToV3],
+  serializeConverters: () => [v3ToV2, v2ToV1]
+});
+var CONN_VERSIONED = _vbare.createVersionedDataHandler.call(void 0, {
+  deserializeVersion: (bytes, version) => {
+    switch (version) {
+      case 3:
+        return decodeConn(bytes);
+      default:
+        throw new Error(
+          `Conn type only exists in version 3+, got version ${version}`
+        );
+    }
+  },
+  serializeVersion: (data, version) => {
+    switch (version) {
+      case 3:
+        return encodeConn(data);
+      default:
+        throw new Error(
+          `Conn type only exists in version 3+, got version ${version}`
+        );
+    }
+  },
+  deserializeConverters: () => [],
+  serializeConverters: () => []
+});
+
+// src/driver-helpers/utils.ts
+function serializeEmptyPersistData(input) {
+  const persistData = {
+    input: input !== void 0 ? _chunkAJ36VBHLcjs.bufferToArrayBuffer.call(void 0, cbor.encode(input)) : null,
+    hasInitialized: false,
+    state: _chunkAJ36VBHLcjs.bufferToArrayBuffer.call(void 0, cbor.encode(void 0)),
+    scheduledEvents: []
+  };
+  return ACTOR_VERSIONED.serializeWithEmbeddedVersion(
+    persistData,
+    CURRENT_VERSION
+  );
+}
+function getInitialActorKvState(input) {
+  const persistData = serializeEmptyPersistData(input);
+  return [[KEYS.PERSIST_DATA, persistData]];
+}
+
+
+
+
+
+
+
+
+
+
+
+exports.CURRENT_VERSION = CURRENT_VERSION; exports.ACTOR_VERSIONED = ACTOR_VERSIONED; exports.CONN_VERSIONED = CONN_VERSIONED; exports.KEYS = KEYS; exports.makeConnKey = makeConnKey; exports.ClientConfigSchema = ClientConfigSchema; exports.DriverConfigSchema = DriverConfigSchema; exports.RunnerConfigSchema = RunnerConfigSchema; exports.getInitialActorKvState = getInitialActorKvState;
+//# sourceMappingURL=chunk-SE37OCA2.cjs.map