@base44/functions-compiler 0.1.0

package/lib/dist/actor.mjs

@@ -0,0 +1,1129 @@
+// GENERATED by scripts/build-shim.ts from src/shim/actor.ts — do not edit.
+// Regenerate with `npm run build:shim`.
+
+// ../../node_modules/partyserver/dist/index.js
+import { DurableObject } from "cloudflare:workers";
+
+// ../../node_modules/nanoid/url-alphabet/index.js
+var urlAlphabet = "useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict";
+
+// ../../node_modules/nanoid/index.browser.js
+var nanoid = (size = 21) => {
+  let id = "";
+  let bytes = crypto.getRandomValues(new Uint8Array(size |= 0));
+  while (size--) {
+    id += urlAlphabet[bytes[size] & 63];
+  }
+  return id;
+};
+
+// ../../node_modules/partyserver/dist/index.js
+if (!("OPEN" in WebSocket)) {
+  const WebSocketStatus = {
+    CONNECTING: WebSocket.READY_STATE_CONNECTING,
+    OPEN: WebSocket.READY_STATE_OPEN,
+    CLOSING: WebSocket.READY_STATE_CLOSING,
+    CLOSED: WebSocket.READY_STATE_CLOSED
+  };
+  Object.assign(WebSocket, WebSocketStatus);
+  Object.assign(WebSocket.prototype, WebSocketStatus);
+}
+var AttachmentCache = class {
+  #cache = /* @__PURE__ */ new WeakMap();
+  get(ws) {
+    let attachment = this.#cache.get(ws);
+    if (!attachment) {
+      attachment = WebSocket.prototype.deserializeAttachment.call(
+        ws
+      );
+      if (attachment !== void 0) {
+        this.#cache.set(ws, attachment);
+      } else {
+        throw new Error(
+          "Missing websocket attachment. This is most likely an issue in PartyServer, please open an issue at https://github.com/threepointone/partyserver/issues"
+        );
+      }
+    }
+    return attachment;
+  }
+  set(ws, attachment) {
+    this.#cache.set(ws, attachment);
+    WebSocket.prototype.serializeAttachment.call(ws, attachment);
+  }
+};
+var attachments = new AttachmentCache();
+var connections = /* @__PURE__ */ new WeakSet();
+var isWrapped = (ws) => {
+  return connections.has(ws);
+};
+var createLazyConnection = (ws) => {
+  if (isWrapped(ws)) {
+    return ws;
+  }
+  let initialState = void 0;
+  if ("state" in ws) {
+    initialState = ws.state;
+    delete ws.state;
+  }
+  const connection = Object.defineProperties(ws, {
+    id: {
+      get() {
+        return attachments.get(ws).__pk.id;
+      }
+    },
+    server: {
+      get() {
+        return attachments.get(ws).__pk.server;
+      }
+    },
+    socket: {
+      get() {
+        return ws;
+      }
+    },
+    state: {
+      get() {
+        return ws.deserializeAttachment();
+      }
+    },
+    setState: {
+      value: function setState(setState) {
+        let state;
+        if (setState instanceof Function) {
+          state = setState(this.state);
+        } else {
+          state = setState;
+        }
+        ws.serializeAttachment(state);
+        return state;
+      }
+    },
+    deserializeAttachment: {
+      value: function deserializeAttachment() {
+        const attachment = attachments.get(ws);
+        return attachment.__user ?? null;
+      }
+    },
+    serializeAttachment: {
+      value: function serializeAttachment(attachment) {
+        const setting = {
+          ...attachments.get(ws),
+          __user: attachment ?? null
+        };
+        attachments.set(ws, setting);
+      }
+    }
+  });
+  if (initialState) {
+    connection.setState(initialState);
+  }
+  connections.add(connection);
+  return connection;
+};
+var HibernatingConnectionIterator = class {
+  constructor(state, tag) {
+    this.state = state;
+    this.tag = tag;
+  }
+  index = 0;
+  sockets;
+  [Symbol.iterator]() {
+    return this;
+  }
+  next() {
+    const sockets = this.sockets ?? (this.sockets = this.state.getWebSockets(this.tag));
+    let socket;
+    while (socket = sockets[this.index++]) {
+      if (socket.readyState === WebSocket.READY_STATE_OPEN) {
+        const value = createLazyConnection(socket);
+        return { done: false, value };
+      }
+    }
+    return { done: true, value: void 0 };
+  }
+};
+var InMemoryConnectionManager = class {
+  #connections = /* @__PURE__ */ new Map();
+  tags = /* @__PURE__ */ new WeakMap();
+  getCount() {
+    return this.#connections.size;
+  }
+  getConnection(id) {
+    return this.#connections.get(id);
+  }
+  *getConnections(tag) {
+    if (!tag) {
+      yield* this.#connections.values();
+      return;
+    }
+    for (const connection of this.#connections.values()) {
+      const connectionTags = this.tags.get(connection) ?? [];
+      if (connectionTags.includes(tag)) {
+        yield connection;
+      }
+    }
+  }
+  accept(connection, options) {
+    connection.accept();
+    this.#connections.set(connection.id, connection);
+    this.tags.set(connection, [
+      // make sure we have id tag
+      connection.id,
+      ...options.tags.filter((t) => t !== connection.id)
+    ]);
+    const removeConnection = () => {
+      this.#connections.delete(connection.id);
+      connection.removeEventListener("close", removeConnection);
+      connection.removeEventListener("error", removeConnection);
+    };
+    connection.addEventListener("close", removeConnection);
+    connection.addEventListener("error", removeConnection);
+    return connection;
+  }
+};
+var HibernatingConnectionManager = class {
+  constructor(controller) {
+    this.controller = controller;
+  }
+  getCount() {
+    return Number(this.controller.getWebSockets().length);
+  }
+  getConnection(id) {
+    const sockets = this.controller.getWebSockets(id);
+    if (sockets.length === 0) return void 0;
+    if (sockets.length === 1)
+      return createLazyConnection(sockets[0]);
+    throw new Error(
+      `More than one connection found for id ${id}. Did you mean to use getConnections(tag) instead?`
+    );
+  }
+  getConnections(tag) {
+    return new HibernatingConnectionIterator(this.controller, tag);
+  }
+  accept(connection, options) {
+    const tags = [
+      connection.id,
+      ...options.tags.filter((t) => t !== connection.id)
+    ];
+    if (tags.length > 10) {
+      throw new Error(
+        "A connection can only have 10 tags, including the default id tag."
+      );
+    }
+    for (const tag of tags) {
+      if (typeof tag !== "string") {
+        throw new Error(`A connection tag must be a string. Received: ${tag}`);
+      }
+      if (tag === "") {
+        throw new Error(`A connection tag must not be an empty string.`);
+      }
+      if (tag.length > 256) {
+        throw new Error(`A connection tag must not exceed 256 characters`);
+      }
+    }
+    this.controller.acceptWebSocket(connection, tags);
+    connection.serializeAttachment({
+      __pk: {
+        id: connection.id,
+        server: options.server
+      },
+      __user: null
+    });
+    return createLazyConnection(connection);
+  }
+};
+var serverMapCache = /* @__PURE__ */ new WeakMap();
+function camelCaseToKebabCase(str) {
+  let kebabified = str.replace(
+    /[A-Z]/g,
+    (letter) => `-${letter.toLowerCase()}`
+  );
+  kebabified = kebabified.startsWith("-") ? kebabified.slice(1) : kebabified;
+  return kebabified.replace(/-$/, "");
+}
+async function routePartykitRequest(req, env, options) {
+  if (!serverMapCache.has(env)) {
+    serverMapCache.set(
+      env,
+      Object.entries(env).reduce((acc, [k, v]) => {
+        if (v && typeof v === "object" && "idFromName" in v && typeof v.idFromName === "function") {
+          return { ...acc, [camelCaseToKebabCase(k)]: v };
+        }
+        return acc;
+      }, {})
+    );
+  }
+  const map = serverMapCache.get(env);
+  const prefix = options?.prefix || "parties";
+  const url = new URL(req.url);
+  const parts = url.pathname.split("/");
+  if (parts[1] === prefix && parts.length < 4) {
+    return null;
+  }
+  const name = parts[3], namespace = parts[2];
+  if (parts[1] === prefix && name && namespace) {
+    if (!map[namespace]) {
+      if (namespace === "main") {
+        console.warn(
+          `You appear to be migrating a PartyKit project to PartyServer.`
+        );
+        console.warn(`PartyServer doesn't have a "main" party by default. Try adding this to your PartySocket client:
+ 
+party: "${camelCaseToKebabCase(Object.keys(map)[0])}"`);
+      } else {
+        console.error(`The url ${req.url} does not match any server namespace. 
+Did you forget to add a durable object binding to the class in your wrangler.toml?`);
+      }
+    }
+    let doNamespace = map[namespace];
+    if (options?.jurisdiction) {
+      doNamespace = doNamespace.jurisdiction(options.jurisdiction);
+    }
+    const id = doNamespace.idFromName(name);
+    const stub = doNamespace.get(id, options);
+    req = new Request(req);
+    req.headers.set("x-partykit-room", name);
+    req.headers.set("x-partykit-namespace", namespace);
+    if (options?.jurisdiction) {
+      req.headers.set("x-partykit-jurisdiction", options.jurisdiction);
+    }
+    return stub.fetch(req);
+  } else {
+    return null;
+  }
+}
+var Server = class extends DurableObject {
+  static options = {
+    hibernate: false
+  };
+  #status = "zero";
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
+  #ParentClass = Object.getPrototypeOf(this).constructor;
+  #connectionManager = this.#ParentClass.options.hibernate ? new HibernatingConnectionManager(this.ctx) : new InMemoryConnectionManager();
+  constructor(ctx, env) {
+    super(ctx, env);
+  }
+  /**
+   * Handle incoming requests to the server.
+   */
+  async fetch(request) {
+    if (!this.#_name) {
+      const room = request.headers.get("x-partykit-room");
+      if (
+        // !namespace ||
+        !room
+      ) {
+        throw new Error(`Missing namespace or room headers when connecting to ${this.#ParentClass.name}.
+Did you try connecting directly to this Durable Object? Try using getServerByName(namespace, id) instead.`);
+      }
+      await this.setName(room);
+    }
+    try {
+      const url = new URL(request.url);
+      if (url.pathname === "/cdn-cgi/partyserver/set-name/") {
+        return Response.json({ ok: true });
+      }
+      if (request.headers.get("Upgrade")?.toLowerCase() !== "websocket") {
+        return await this.onRequest(request);
+      } else {
+        const { 0: clientWebSocket, 1: serverWebSocket } = new WebSocketPair();
+        let connectionId = url.searchParams.get("_pk");
+        if (!connectionId) {
+          connectionId = nanoid();
+        }
+        let connection = Object.assign(serverWebSocket, {
+          id: connectionId,
+          server: this.name,
+          state: null,
+          setState(setState) {
+            let state;
+            if (setState instanceof Function) {
+              state = setState(this.state);
+            } else {
+              state = setState;
+            }
+            this.state = state;
+            return this.state;
+          }
+        });
+        const ctx = { request };
+        const tags = await this.getConnectionTags(connection, ctx);
+        connection = this.#connectionManager.accept(connection, {
+          tags,
+          server: this.name
+        });
+        if (!this.#ParentClass.options.hibernate) {
+          this.#attachSocketEventHandlers(connection);
+        }
+        await this.onConnect(connection, ctx);
+        return new Response(null, { status: 101, webSocket: clientWebSocket });
+      }
+    } catch (err) {
+      console.error(
+        `Error in ${this.#ParentClass.name}:${this.name} fetch:`,
+        err
+      );
+      if (!(err instanceof Error)) throw err;
+      if (request.headers.get("Upgrade") == "websocket") {
+        const pair = new WebSocketPair();
+        pair[1].accept();
+        pair[1].send(JSON.stringify({ error: err.stack }));
+        pair[1].close(1011, "Uncaught exception during session setup");
+        return new Response(null, { status: 101, webSocket: pair[0] });
+      } else {
+        return new Response(err.stack, { status: 500 });
+      }
+    }
+  }
+  async webSocketMessage(ws, message) {
+    const connection = createLazyConnection(ws);
+    await this.setName(connection.server);
+    if (this.#status !== "started") {
+      await this.#initialize();
+    }
+    return this.onMessage(connection, message);
+  }
+  async webSocketClose(ws, code, reason, wasClean) {
+    const connection = createLazyConnection(ws);
+    await this.setName(connection.server);
+    if (this.#status !== "started") {
+      await this.#initialize();
+    }
+    return this.onClose(connection, code, reason, wasClean);
+  }
+  async webSocketError(ws, error) {
+    const connection = createLazyConnection(ws);
+    await this.setName(connection.server);
+    if (this.#status !== "started") {
+      await this.#initialize();
+    }
+    return this.onError(connection, error);
+  }
+  async #initialize() {
+    await this.ctx.blockConcurrencyWhile(async () => {
+      this.#status = "starting";
+      await this.onStart();
+      this.#status = "started";
+    });
+  }
+  #attachSocketEventHandlers(connection) {
+    const handleMessageFromClient = (event) => {
+      this.onMessage(connection, event.data)?.catch((e) => {
+        console.error("onMessage error:", e);
+      });
+    };
+    const handleCloseFromClient = (event) => {
+      connection.removeEventListener("message", handleMessageFromClient);
+      connection.removeEventListener("close", handleCloseFromClient);
+      this.onClose(connection, event.code, event.reason, event.wasClean)?.catch(
+        (e) => {
+          console.error("onClose error:", e);
+        }
+      );
+    };
+    const handleErrorFromClient = (e) => {
+      connection.removeEventListener("message", handleMessageFromClient);
+      connection.removeEventListener("error", handleErrorFromClient);
+      this.onError(connection, e.error)?.catch((e2) => {
+        console.error("onError error:", e2);
+      });
+    };
+    connection.addEventListener("close", handleCloseFromClient);
+    connection.addEventListener("error", handleErrorFromClient);
+    connection.addEventListener("message", handleMessageFromClient);
+  }
+  // Public API
+  #_name;
+  #_longErrorAboutNameThrown = false;
+  /**
+   * The name for this server. Write-once-only.
+   */
+  get name() {
+    if (!this.#_name) {
+      if (!this.#_longErrorAboutNameThrown) {
+        this.#_longErrorAboutNameThrown = true;
+        throw new Error(
+          `Attempting to read .name on ${this.#ParentClass.name} before it was set. The name can be set by explicitly calling .setName(name) on the stub, or by using routePartyKitRequest(). This is a known issue and will be fixed soon. Follow https://github.com/cloudflare/workerd/issues/2240 for more updates.`
+        );
+      } else {
+        throw new Error(
+          `Attempting to read .name on ${this.#ParentClass.name} before it was set.`
+        );
+      }
+    }
+    return this.#_name;
+  }
+  // We won't have an await inside this function
+  // but it will be called remotely,
+  // so we need to mark it as async
+  async setName(name) {
+    if (!name) {
+      throw new Error("A name is required.");
+    }
+    if (this.#_name && this.#_name !== name) {
+      throw new Error("This server already has a name.");
+    }
+    this.#_name = name;
+    if (this.#status !== "started") {
+      await this.ctx.blockConcurrencyWhile(async () => {
+        await this.#initialize();
+      });
+    }
+  }
+  #sendMessageToConnection(connection, message) {
+    try {
+      connection.send(message);
+    } catch (_e) {
+      connection.close(1011, "Unexpected error");
+    }
+  }
+  /** Send a message to all connected clients, except connection ids listed in `without` */
+  broadcast(msg, without) {
+    for (const connection of this.#connectionManager.getConnections()) {
+      if (!without || !without.includes(connection.id)) {
+        this.#sendMessageToConnection(connection, msg);
+      }
+    }
+  }
+  /** Get a connection by connection id */
+  getConnection(id) {
+    return this.#connectionManager.getConnection(id);
+  }
+  /**
+   * Get all connections. Optionally, you can provide a tag to filter returned connections.
+   * Use `Server#getConnectionTags` to tag the connection on connect.
+   */
+  getConnections(tag) {
+    return this.#connectionManager.getConnections(tag);
+  }
+  /**
+   * You can tag a connection to filter them in Server#getConnections.
+   * Each connection supports up to 9 tags, each tag max length is 256 characters.
+   */
+  getConnectionTags(connection, context) {
+    return [];
+  }
+  // Implemented by the user
+  /**
+   * Called when the server is started for the first time.
+   */
+  onStart() {
+  }
+  /**
+   * Called when a new connection is made to the server.
+   */
+  onConnect(connection, ctx) {
+    console.log(
+      `Connection ${connection.id} connected to ${this.#ParentClass.name}:${this.name}`
+    );
+  }
+  /**
+   * Called when a message is received from a connection.
+   */
+  onMessage(connection, message) {
+    console.log(
+      `Received message on connection ${this.#ParentClass.name}:${connection.id}`
+    );
+    console.info(
+      `Implement onMessage on ${this.#ParentClass.name} to handle this message.`
+    );
+  }
+  /**
+   * Called when a connection is closed.
+   */
+  onClose(connection, code, reason, wasClean) {
+  }
+  /**
+   * Called when an error occurs on a connection.
+   */
+  onError(connection, error) {
+    console.error(
+      `Error on connection ${connection.id} in ${this.#ParentClass.name}:${this.name}:`,
+      error
+    );
+    console.info(
+      `Implement onError on ${this.#ParentClass.name} to handle this error.`
+    );
+  }
+  /**
+   * Called when a request is made to the server.
+   */
+  onRequest(request) {
+    console.warn(
+      `onRequest hasn't been implemented on ${this.#ParentClass.name}:${this.name} responding to ${request.url}`
+    );
+    return new Response(`Not implemented`, { status: 404 });
+  }
+  onAlarm() {
+    console.log(
+      `Implement onAlarm on ${this.#ParentClass.name} to handle alarms.`
+    );
+  }
+  async alarm() {
+    if (this.#status !== "started") {
+      await this.#initialize();
+    }
+    await this.onAlarm();
+  }
+};
+
+// src/shim/actor.ts
+import { createClient } from "npm:@base44/sdk@0.8.41";
+
+// src/shim/tick-loop.ts
+var TickLoop = class {
+  constructor(onTick, maxCatchup = 3) {
+    this.onTick = onTick;
+    this.maxCatchup = maxCatchup;
+  }
+  onTick;
+  maxCatchup;
+  timer = null;
+  nextAt = 0;
+  running = false;
+  intervalMs = 0;
+  // A run() resuming after stop()+start() must not arm a second, untracked
+  // timer — each run() acts only for its own generation.
+  gen = 0;
+  get isRunning() {
+    return this.running;
+  }
+  start(intervalMs) {
+    if (this.running) {
+      if (intervalMs === this.intervalMs) return;
+      this.intervalMs = intervalMs;
+      this.nextAt = Date.now() + intervalMs;
+      if (this.timer !== null) {
+        clearTimeout(this.timer);
+        this.timer = null;
+        this.schedule();
+      }
+      return;
+    }
+    this.running = true;
+    this.intervalMs = intervalMs;
+    this.nextAt = Date.now() + intervalMs;
+    this.schedule();
+  }
+  stop() {
+    this.running = false;
+    this.gen++;
+    if (this.timer !== null) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+  }
+  schedule() {
+    this.timer = setTimeout(() => {
+      void this.run();
+    }, Math.max(0, this.nextAt - Date.now()));
+  }
+  async run() {
+    const gen = this.gen;
+    this.timer = null;
+    let steps = 0;
+    while (this.running && this.gen === gen && Date.now() >= this.nextAt && steps < this.maxCatchup) {
+      steps++;
+      this.nextAt += this.intervalMs;
+      let keep = true;
+      try {
+        keep = await this.onTick();
+      } catch (err) {
+        console.error("TickLoop tick threw:", err);
+      }
+      if (this.gen !== gen) return;
+      if (!keep) {
+        this.stop();
+        return;
+      }
+    }
+    if (!this.running || this.gen !== gen) return;
+    if (Date.now() >= this.nextAt) this.nextAt = Date.now() + this.intervalMs;
+    this.schedule();
+  }
+};
+
+// src/shim/actor.ts
+var SUPERSEDED_PREFIX = "__superseded__:";
+function buildConn(ws, identity) {
+  return {
+    id: ws.id,
+    // partyserver's per-connection id (survives hibernation)
+    ...identity ? { identity } : {},
+    send(data) {
+      ws.send(JSON.stringify(data));
+    },
+    reject(code, reason) {
+      ws.close(code, reason);
+    }
+  };
+}
+var Actor = class _Actor extends Server {
+  // WebSocket Hibernation: idle rooms are evicted from memory (no duration
+  // billing) with sockets kept open; onStart re-runs on wake to rehydrate. A
+  // ticking room stays resident (its setTimeout loop blocks hibernation), so this
+  // only affects non-ticking occupied rooms. Statics inherit, so a handler opts
+  // out with `static options = { hibernate: false }`.
+  static options = { hibernate: true };
+  // conn.id is client-chosen and partyserver silently REPLACES a same-id socket
+  // on accept, so a duplicate must be resolved before super.fetch(). Liveness
+  // (SDK pings every 1s) distinguishes a real conflict from a reconnect.
+  lastSeen = /* @__PURE__ */ new Map();
+  identities = /* @__PURE__ */ new Map();
+  static LIVE_MS = 3e3;
+  static IDENTITY_HEADER = "X-Base44-Actor-Identity";
+  // Captured at construction so `client` reads this DO's own env, not the shared
+  // globalThis.Base44 bridge (which the last-constructed DO in the isolate wins).
+  _b44Env;
+  _b44Client;
+  get client() {
+    return this._b44Client ??= new Proxy(
+      createClient({
+        appId: this._b44Env.BASE44_APP_ID,
+        serverUrl: this._b44Env.BASE44_API_URL,
+        // "prod" on the published script, "preview" on the draft — set at deploy.
+        functionsVersion: this._b44Env.BASE44_FUNCTIONS_VERSION
+      }),
+      {
+        // The SDK bakes serviceToken into axios defaults at createClient time and
+        // its own asServiceRole getter throws without one, so that one property is
+        // answered by the lazy exchange below instead.
+        get: (target, prop) => prop === "asServiceRole" ? this._b44ServiceRolePath([]) : Reflect.get(target, prop, target)
+      }
+    );
+  }
+  // ── Service role ──────────────────────────────────────────────────────
+  // The token is fetched on the first privileged call by trading an assertion
+  // signed with the actor's private key, cached in memory, and re-fetched
+  // after expiry. Hibernation wiping the cache just means the next call
+  // exchanges again — nothing durable is stored.
+  _b44Service = null;
+  _b44ServicePending = null;
+  async _b44SignServiceAssertion(privateKey, publicKey) {
+    const b64url = (bin) => btoa(bin).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+    const now = Math.floor(Date.now() / 1e3);
+    const claims = {
+      iss: "base44-actor",
+      aud: "base44-actor-service-token",
+      purpose: "actor-service-token",
+      v: 1,
+      iat: now,
+      exp: now + 60,
+      app_id: this._b44Env.BASE44_APP_ID,
+      actor_name: this.constructor._b44ActorName
+    };
+    const input = `${b64url(JSON.stringify({ alg: "EdDSA", typ: "JWT" }))}.${b64url(JSON.stringify(claims))}`;
+    const key = await crypto.subtle.importKey(
+      "jwk",
+      { kty: "OKP", crv: "Ed25519", d: privateKey, x: publicKey },
+      { name: "Ed25519" },
+      false,
+      ["sign"]
+    );
+    const signature = new Uint8Array(
+      await crypto.subtle.sign({ name: "Ed25519" }, key, new TextEncoder().encode(input))
+    );
+    return `${input}.${b64url(String.fromCharCode(...signature))}`;
+  }
+  async _b44FetchServiceClient() {
+    const privateKey = this._b44Env.BASE44_ACTOR_PRIVATE_KEY;
+    const publicKey = this._b44Env.BASE44_ACTOR_PUBLIC_KEY;
+    if (typeof privateKey !== "string" || !privateKey || typeof publicKey !== "string" || !publicKey) {
+      throw new Error(
+        "asServiceRole is unavailable on this actor: it predates direct connections. Delete the actor and deploy it again (room storage is not preserved)."
+      );
+    }
+    const response = await fetch(
+      `${this._b44Env.BASE44_API_URL}/api/apps/${this._b44Env.BASE44_APP_ID}/actors/service-token`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ assertion: await this._b44SignServiceAssertion(privateKey, publicKey) })
+      }
+    );
+    if (!response.ok) {
+      throw new Error(`Actor service token exchange failed (${response.status})`);
+    }
+    const { access_token, expires_in } = await response.json();
+    const client = createClient({
+      appId: this._b44Env.BASE44_APP_ID,
+      serverUrl: this._b44Env.BASE44_API_URL,
+      functionsVersion: this._b44Env.BASE44_FUNCTIONS_VERSION,
+      serviceToken: access_token
+    });
+    this._b44Service = { client, expiresAtMs: Date.now() + (expires_in - 60) * 1e3 };
+    return client;
+  }
+  _b44ServiceClient() {
+    if (this._b44Service && Date.now() < this._b44Service.expiresAtMs) {
+      return Promise.resolve(this._b44Service.client);
+    }
+    return this._b44ServicePending ??= this._b44FetchServiceClient().finally(() => {
+      this._b44ServicePending = null;
+    });
+  }
+  // asServiceRole is a sync property chain ending in an async call, so proxies
+  // record the chain and the exchange awaits inside the final call — actor code
+  // reads identically to backend functions.
+  _b44ServiceRolePath(path) {
+    const self = this;
+    return new Proxy(function() {
+    }, {
+      get(_target, prop) {
+        if (typeof prop === "symbol" || prop === "then") return void 0;
+        return self._b44ServiceRolePath([...path, prop]);
+      },
+      async apply(_target, _thisArg, args) {
+        const serviceClient = await self._b44ServiceClient();
+        let parent = serviceClient.asServiceRole;
+        for (const prop of path.slice(0, -1)) parent = parent[prop];
+        return parent[path[path.length - 1]](...args);
+      }
+    });
+  }
+  // Reserved platform keys — the private-data-sources manifest carries
+  // plaintext VPC DB credentials. Keep in sync with worker-entry.ts.
+  static RESERVED_SECRETS = /* @__PURE__ */ new Set([
+    "BASE44_ACTOR_PRIVATE_KEY",
+    "BASE44_ACTOR_PUBLIC_KEY",
+    "BASE44_ACTOR_SCRIPT_ID",
+    "BASE44_PRIVATE_DATA_SOURCES"
+  ]);
+  constructor(ctx, env) {
+    super(ctx, env);
+    this._b44Env = env;
+    globalThis.Base44 = Object.assign(
+      globalThis.Base44 ?? {},
+      {
+        // DOs have no request-scoped waitUntil (they stay alive while
+        // connections exist) — absorb so shared function code doesn't crash.
+        waitUntil: (p) => {
+          Promise.resolve(p).catch(() => {
+          });
+        },
+        secrets: {
+          // String(n) BEFORE the reserved check: a boxed String fails Set.has
+          // yet coerces back to the reserved key on the env lookup.
+          get: (n) => {
+            const key = String(n);
+            if (_Actor.RESERVED_SECRETS.has(key)) return void 0;
+            const v = env[key];
+            return typeof v === "string" ? v : void 0;
+          }
+        }
+      }
+    );
+  }
+  async onStart() {
+    try {
+      this.ctx.setWebSocketAutoResponse(
+        new WebSocketRequestResponsePair(
+          JSON.stringify({ type: "__ping" }),
+          JSON.stringify({ type: "__pong" })
+        )
+      );
+    } catch {
+    }
+    await this.handleStart();
+    await this.maintainTicker();
+  }
+  livenessMs(ws) {
+    let autoResp = 0;
+    try {
+      autoResp = this.ctx.getWebSocketAutoResponseTimestamp(ws)?.getTime() ?? 0;
+    } catch {
+    }
+    return Math.max(this.lastSeen.get(ws.id) ?? 0, autoResp);
+  }
+  static parseIdentity(value) {
+    if (!value || value.length > 512) return void 0;
+    try {
+      const identity = JSON.parse(value);
+      if (identity.type === "authenticated" && typeof identity.userId === "string" && identity.userId.length > 0 && identity.userId.length <= 128) {
+        return Object.freeze({ type: "authenticated", userId: identity.userId });
+      }
+      if (identity.type === "anonymous" && typeof identity.anonymousId === "string" && identity.anonymousId.length > 0 && identity.anonymousId.length <= 128) {
+        return Object.freeze({ type: "anonymous", anonymousId: identity.anonymousId });
+      }
+    } catch {
+      return void 0;
+    }
+    return void 0;
+  }
+  identityFor(ws) {
+    if (this.identities.has(ws.id)) return this.identities.get(ws.id);
+    let identity;
+    try {
+      identity = ws.deserializeAttachment()?.__base44Identity;
+      if (identity) Object.freeze(identity);
+    } catch {
+    }
+    this.identities.set(ws.id, identity);
+    return identity;
+  }
+  // partyserver's fetch() catch re-throws "Network connection lost." when the
+  // client already went away; swallow it so it isn't logged as an exception.
+  async fetch(request) {
+    if (request.headers.get("Upgrade")?.toLowerCase() === "websocket") {
+      const pk = new URL(request.url).searchParams.get("_pk");
+      if (pk) {
+        const existing = [...super.getConnections()].find((c) => c.id === pk);
+        if (existing !== void 0 && Date.now() - this.livenessMs(existing) < _Actor.LIVE_MS) {
+          return new Response("Connection id already in use", { status: 409 });
+        }
+        if (existing !== void 0) {
+          try {
+            const att = existing.deserializeAttachment() ?? {};
+            existing.serializeAttachment({ ...att, __superseded: true });
+          } catch {
+          }
+          try {
+            existing.id = `${SUPERSEDED_PREFIX}${pk}`;
+          } catch {
+          }
+          try {
+            existing.close(4408, "Superseded by reconnect");
+          } catch {
+          }
+        }
+      }
+    }
+    try {
+      return await super.fetch(request);
+    } catch (err) {
+      if (err instanceof Error && err.message.includes("Network connection lost")) {
+        return new Response("Connection lost", { status: 503 });
+      }
+      throw err;
+    }
+  }
+  async onConnect(ws, ctx) {
+    const identity = _Actor.parseIdentity(
+      ctx.request.headers.get(_Actor.IDENTITY_HEADER)
+    );
+    this.identities.set(ws.id, identity);
+    if (identity) {
+      try {
+        const attachment = ws.deserializeAttachment() ?? {};
+        ws.serializeAttachment({ ...attachment, __base44Identity: identity });
+      } catch {
+      }
+    }
+    this.lastSeen.set(ws.id, Date.now());
+    await this.handleConnect(buildConn(ws, identity));
+    await this.maintainTicker();
+  }
+  async onMessage(ws, raw) {
+    this.lastSeen.set(ws.id, Date.now());
+    let msg;
+    try {
+      msg = JSON.parse(raw);
+    } catch {
+      return;
+    }
+    if (msg?.type === "__ping") {
+      ws.send(JSON.stringify({ type: "__pong" }));
+      await this.maintainTicker();
+      return;
+    }
+    await this.handleMessage(buildConn(ws, this.identityFor(ws)), msg);
+    await this.maintainTicker();
+  }
+  async onClose(ws) {
+    let superseded = ws.id.startsWith(SUPERSEDED_PREFIX);
+    if (!superseded) {
+      try {
+        superseded = !!ws.deserializeAttachment()?.__superseded;
+      } catch {
+      }
+    }
+    if (superseded) return;
+    const identity = this.identityFor(ws);
+    this.lastSeen.delete(ws.id);
+    this.identities.delete(ws.id);
+    await this.handleClose(buildConn(ws, identity));
+    await this.maintainTicker();
+  }
+  // WATCHDOG, not the metronome (see tick-loop.ts): resumes the loop after
+  // eviction / self-heals a dead one. Never runs handleTick itself.
+  async onAlarm() {
+    const gen = this.tickerGen;
+    const now = Date.now();
+    const due = await this.mutateSchedules((m) => {
+      const d = Object.keys(m).filter((k) => m[k] <= now);
+      for (const k of d) delete m[k];
+      return d;
+    });
+    for (const key of due) {
+      try {
+        await this.handleWake(key);
+      } catch (err) {
+        console.error("Actor.handleWake threw:", err);
+      }
+    }
+    const ms = this.loopMs ?? await this.ctx.storage.get("__loop_ms");
+    if (gen !== this.tickerGen) return;
+    if (ms) {
+      this.loopMs = ms;
+      if (typeof this.shouldTick === "function" && !([...super.getConnections()].length > 0 && this.shouldTick())) {
+        this.ticking = false;
+        await this.stopLoop();
+        return;
+      }
+      if (!this.loop.isRunning) this.loop.start(ms);
+    }
+    await this.rearmAlarm();
+  }
+  handleWake(_key) {
+  }
+  async schedule(key, at) {
+    const when = typeof at === "number" ? at : at.getTime();
+    await this.mutateSchedules((m) => {
+      m[key] = when;
+    });
+    await this.rearmAlarm();
+  }
+  async cancelSchedule(key) {
+    await this.mutateSchedules((m) => {
+      delete m[key];
+    });
+    await this.rearmAlarm();
+  }
+  // Concurrent read-modify-writes of the map would drop each other's keys
+  // (two schedule() calls both reading the prior map); chain them instead.
+  schedulesChain = Promise.resolve();
+  mutateSchedules(fn) {
+    const run = this.schedulesChain.then(async () => {
+      const m = await this.ctx.storage.get("__schedules") ?? {};
+      const out = fn(m);
+      await this.ctx.storage.put("__schedules", m);
+      return out;
+    });
+    this.schedulesChain = run.catch(() => {
+    });
+    return run;
+  }
+  // The single DO alarm serves the ticker watchdog AND scheduled wakes: arm to
+  // whichever is earliest; clear only when neither needs it. Chained on the
+  // schedules queue so a rearm that read the map before a queued mutation can
+  // never act after that mutation's own rearm and clobber it.
+  rearmAlarm() {
+    const run = this.schedulesChain.then(async () => {
+      const wakes = Object.values(
+        await this.ctx.storage.get("__schedules") ?? {}
+      );
+      const nextWake = wakes.length ? Math.min(...wakes) : null;
+      const watchdog = this.loop.isRunning ? Date.now() + _Actor.WATCHDOG_MS : null;
+      const next = nextWake === null ? watchdog : watchdog === null ? nextWake : Math.min(nextWake, watchdog);
+      if (next === null) await this.ctx.storage.deleteAlarm();
+      else await this.ctx.storage.setAlarm(next);
+    });
+    this.schedulesChain = run.catch(() => {
+    });
+    return run;
+  }
+  // Optional wake hook: once per instance start, before any connection.
+  handleStart() {
+  }
+  // ─── Managed ticker (opt-in) ──────────────────────────────────────────────
+  // Override shouldTick() and the platform runs handleTick() on a timer while it
+  // returns true, stopping (the DO can idle out) when false. shouldTick()
+  // must be cheap and pure: it runs after every lifecycle event and tick.
+  tickIntervalMs = 100;
+  ticking = false;
+  loopMs = null;
+  // in-memory mirror of __loop_ms
+  loop = new TickLoop(() => this.runOneTick());
+  static WATCHDOG_MS = 3e4;
+  // One tick: a throw skips the tick, never kills the loop.
+  async runOneTick() {
+    const gen = this.tickerGen;
+    try {
+      await this.handleTick();
+    } catch (err) {
+      console.error("Actor.handleTick threw:", err);
+    }
+    if (gen !== this.tickerGen) return false;
+    if (typeof this.shouldTick === "function") {
+      const keep = [...super.getConnections()].length > 0 && this.shouldTick();
+      this.ticking = keep;
+      if (!keep) {
+        await this.stopLoop();
+        return false;
+      }
+      return true;
+    }
+    return this.loopMs != null;
+  }
+  broadcast(data) {
+    super.broadcast(JSON.stringify(data));
+  }
+  getConnections() {
+    return [...super.getConnections()].map((ws) => buildConn(ws, this.identityFor(ws)));
+  }
+  // The newest start/stop owns the persisted state: a stale transition
+  // resuming after its await must not erase a fresh __loop_ms/watchdog.
+  tickerGen = 0;
+  async startLoop(ms) {
+    const gen = ++this.tickerGen;
+    this.loopMs = ms;
+    await this.ctx.storage.put("__loop_ms", ms);
+    if (gen !== this.tickerGen) return;
+    this.loop.start(ms);
+    await this.rearmAlarm();
+  }
+  async stopLoop() {
+    const gen = ++this.tickerGen;
+    this.loop.stop();
+    this.loopMs = null;
+    this.ticking = false;
+    await this.ctx.storage.delete("__loop_ms");
+    if (gen !== this.tickerGen) return;
+    await this.rearmAlarm();
+  }
+  // Restart a dead in-memory loop (eviction / isolate reload).
+  async ensureLoop() {
+    if (this.loopMs == null) {
+      const gen = this.tickerGen;
+      const ms = await this.ctx.storage.get("__loop_ms");
+      if (gen !== this.tickerGen) return;
+      if (!ms) return;
+      this.loopMs = ms;
+    }
+    if (!this.loop.isRunning) this.loop.start(this.loopMs);
+  }
+  // Managed-ticker reconcile: run after every lifecycle event. The ticker is
+  // opt-in via shouldTick() — a handler that doesn't define it never ticks.
+  // When opted in, start/stop the loop to match, self-healing a dead loop
+  // while still wanted.
+  async maintainTicker() {
+    if (typeof this.shouldTick !== "function") return;
+    const want = [...super.getConnections()].length > 0 && this.shouldTick();
+    if (want !== this.ticking) {
+      this.ticking = want;
+      if (want) await this.startLoop(this.tickIntervalMs);
+      else await this.stopLoop();
+    } else if (want) {
+      await this.ensureLoop();
+    }
+  }
+  get instanceId() {
+    return this.name;
+  }
+  get storage() {
+    const store = this.ctx.storage;
+    return {
+      get: (key) => store.get(key),
+      put: (key, value) => store.put(key, value),
+      delete: (key) => store.delete(key),
+      deleteAll: async () => {
+        await this.stopLoop();
+        await store.deleteAll();
+      }
+    };
+  }
+};
+export {
+  Actor,
+  routePartykitRequest
+};