@orpc/experimental-publisher-durable-object 0.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 oRPC
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,81 @@
+<div align="center">
+  <image align="center" src="https://orpc.unnoq.com/logo.webp" width=280 alt="oRPC logo" />
+</div>
+
+<h1></h1>
+
+<div align="center">
+  <a href="https://codecov.io/gh/unnoq/orpc">
+    <img alt="codecov" src="https://codecov.io/gh/unnoq/orpc/branch/main/graph/badge.svg">
+  </a>
+  <a href="https://www.npmjs.com/package/@orpc/experimental-publisher-durable-object">
+    <img alt="weekly downloads" src="https://img.shields.io/npm/dw/%40orpc%2Fexperimental-publisher-durable-object?logo=npm" />
+  </a>
+  <a href="https://github.com/unnoq/orpc/blob/main/LICENSE">
+    <img alt="MIT License" src="https://img.shields.io/github/license/unnoq/orpc?logo=open-source-initiative" />
+  </a>
+  <a href="https://discord.gg/TXEbwRBvQn">
+    <img alt="Discord" src="https://img.shields.io/discord/1308966753044398161?color=7389D8&label&logo=discord&logoColor=ffffff" />
+  </a>
+  <a href="https://deepwiki.com/unnoq/orpc">
+    <img src="https://deepwiki.com/badge.svg" alt="Ask DeepWiki">
+  </a>
+</div>
+
+<h3 align="center">Typesafe APIs Made Simple 🪄</h3>
+
+**oRPC is a powerful combination of RPC and OpenAPI**, makes it easy to build APIs that are end-to-end type-safe and adhere to OpenAPI standards
+
+---
+
+## Highlights
+
+- **🔗 End-to-End Type Safety**: Ensure type-safe inputs, outputs, and errors from client to server.
+- **📘 First-Class OpenAPI**: Built-in support that fully adheres to the OpenAPI standard.
+- **📝 Contract-First Development**: Optionally define your API contract before implementation.
+- **🔍 First-Class OpenTelemetry**: Seamlessly integrate with OpenTelemetry for observability.
+- **⚙️ Framework Integrations**: Seamlessly integrate with TanStack Query (React, Vue, Solid, Svelte, Angular), SWR, Pinia Colada, and more.
+- **🚀 Server Actions**: Fully compatible with React Server Actions on Next.js, TanStack Start, and other platforms.
+- **🔠 Standard Schema Support**: Works out of the box with Zod, Valibot, ArkType, and other schema validators.
+- **🗃️ Native Types**: Supports native types like Date, File, Blob, BigInt, URL, and more.
+- **⏱️ Lazy Router**: Enhance cold start times with our lazy routing feature.
+- **📡 SSE & Streaming**: Enjoy full type-safe support for SSE and streaming.
+- **🌍 Multi-Runtime Support**: Fast and lightweight on Cloudflare, Deno, Bun, Node.js, and beyond.
+- **🔌 Extendability**: Easily extend functionality with plugins, middleware, and interceptors.
+
+## Documentation
+
+You can find the full documentation [here](https://orpc.unnoq.com).
+
+## Packages
+
+- [@orpc/contract](https://www.npmjs.com/package/@orpc/contract): Build your API contract.
+- [@orpc/server](https://www.npmjs.com/package/@orpc/server): Build your API or implement API contract.
+- [@orpc/client](https://www.npmjs.com/package/@orpc/client): Consume your API on the client with type-safety.
+- [@orpc/openapi](https://www.npmjs.com/package/@orpc/openapi): Generate OpenAPI specs and handle OpenAPI requests.
+- [@orpc/otel](https://www.npmjs.com/package/@orpc/otel): [OpenTelemetry](https://opentelemetry.io/) integration for observability.
+- [@orpc/nest](https://www.npmjs.com/package/@orpc/nest): Deeply integrate oRPC with [NestJS](https://nestjs.com/).
+- [@orpc/react](https://www.npmjs.com/package/@orpc/react): Utilities for integrating oRPC with React and React Server Actions.
+- [@orpc/tanstack-query](https://www.npmjs.com/package/@orpc/tanstack-query): [TanStack Query](https://tanstack.com/query/latest) integration.
+- [@orpc/experimental-react-swr](https://www.npmjs.com/package/@orpc/experimental-react-swr): [SWR](https://swr.vercel.app/) integration.
+- [@orpc/vue-colada](https://www.npmjs.com/package/@orpc/vue-colada): Integration with [Pinia Colada](https://pinia-colada.esm.dev/).
+- [@orpc/hey-api](https://www.npmjs.com/package/@orpc/hey-api): [Hey API](https://heyapi.dev/) integration.
+- [@orpc/zod](https://www.npmjs.com/package/@orpc/zod): More schemas that [Zod](https://zod.dev/) doesn't support yet.
+- [@orpc/valibot](https://www.npmjs.com/package/@orpc/valibot): OpenAPI spec generation from [Valibot](https://valibot.dev/).
+- [@orpc/arktype](https://www.npmjs.com/package/@orpc/arktype): OpenAPI spec generation from [ArkType](https://arktype.io/).
+
+## `@orpc/experimental-publisher-durable-object`
+
+Publisher adapter for [Durable Objects](https://developers.cloudflare.com/durable-objects/)
+
+## Sponsors
+
+<p align="center">
+  <a href="https://cdn.jsdelivr.net/gh/unnoq/unnoq/sponsors.svg">
+    <img src='https://cdn.jsdelivr.net/gh/unnoq/unnoq/sponsors.svg'/>
+  </a>
+</p>
+
+## License
+
+Distributed under the MIT License. See [LICENSE](https://github.com/unnoq/orpc/blob/main/LICENSE) for more information.

package/dist/index.d.mts

@@ -0,0 +1,108 @@
+import { DurableObject } from 'cloudflare:workers';
+import { StandardRPCJsonSerializerOptions } from '@orpc/client/standard';
+import { PublisherOptions, Publisher, PublisherSubscribeListenerOptions } from '@orpc/experimental-publisher';
+import { EventMeta } from '@orpc/standard-server';
+
+interface ResumeStorageOptions {
+    /**
+     * How long (in seconds) to retain events for replay.
+     *
+     * When a client reconnects, stored events within this window can be replayed
+     * to ensure no data is lost. Outside this window, missed events are dropped.
+     *
+     * @remarks
+     * - Use 0, negative or infinite numbers to disable resume functionality
+     * - Event cleanup is deferred for performance reasons — expired events may
+     *   remain briefly beyond their retention time
+     *
+     * @default 0 (disabled)
+     */
+    retentionSeconds?: number;
+    /**
+     * How long (in seconds) of inactivity before auto-deleting the durable object's data.
+     * Inactivity means no active WebSocket connections and no events within the retention period.
+     *
+     * The alarm is scheduled at `retentionSeconds + inactiveDataRetentionTime`.
+     *
+     * @default 6 * 60 * 60 (6 hours)
+     */
+    inactiveDataRetentionTime?: number;
+    /**
+     * Prefix for the resume storage table schema.
+     * Used to avoid naming conflicts with other tables in the same Durable Object.
+     *
+     * @default 'orpc:publisher:resume:'
+     */
+    schemaPrefix?: string;
+}
+declare class ResumeStorage {
+    private readonly ctx;
+    private readonly retentionSeconds;
+    private readonly inactiveDataRetentionTime;
+    private readonly schemaPrefix;
+    private isInitedSchema;
+    private isInitedAlarm;
+    private lastCleanupTime;
+    get isEnabled(): boolean;
+    constructor(ctx: DurableObjectState, options?: ResumeStorageOptions);
+    /**
+     * Store an event and return the updated serialized message with an assigned ID.
+     */
+    store(stringified: string): Promise<string>;
+    /**
+     * Get all events after the specified lastEventId, ordered by ID ascending.
+     */
+    getEventsAfter(lastEventId: string): Promise<string[]>;
+    /**
+     * Auto-delete durable object data if inactive for extended period.
+     * Inactivity means: no active connections AND no active events.
+     */
+    alarm(): Promise<void>;
+    private ensureReady;
+    private resetData;
+    private scheduleAlarm;
+}
+
+interface PublisherDurableObjectOptions {
+    resume?: ResumeStorageOptions;
+}
+declare class PublisherDurableObject<Env = Cloudflare.Env, Props = {}> extends DurableObject<Env, Props> {
+    private readonly resumeStorage;
+    constructor(ctx: DurableObjectState<Props>, env: Env, options?: PublisherDurableObjectOptions);
+    fetch(request: Request): Promise<Response>;
+    private handlePublish;
+    private handleSubscribe;
+    alarm(): Promise<void>;
+}
+
+interface DurablePublisherOptions extends PublisherOptions, StandardRPCJsonSerializerOptions {
+    /**
+     * Prefix for events, to avoid naming conflicts with other publishers in the same Durable Object.
+     *
+     * @default ''
+     */
+    prefix?: string;
+    /**
+     * Custom function to get the Durable Object stub for publishing.
+     *
+     * @default ((namespace, event) => namespace.getByName(event))
+     */
+    getStubByName?: (namespace: DurableObjectNamespace, event: string) => DurableObjectStub;
+}
+declare class DurablePublisher<T extends Record<string, object>> extends Publisher<T> {
+    private readonly namespace;
+    private readonly prefix;
+    private readonly serializer;
+    private readonly getStubByName;
+    constructor(namespace: DurableObjectNamespace, { prefix, getStubByName, ...options }?: DurablePublisherOptions);
+    publish<K extends keyof T & string>(event: K, payload: T[K]): Promise<void>;
+    protected subscribeListener<K extends keyof T & string>(event: K, listener: (payload: T[K]) => void, options?: PublisherSubscribeListenerOptions): Promise<() => Promise<void>>;
+}
+
+interface SerializedMessage {
+    data: unknown;
+    meta?: EventMeta;
+}
+
+export { DurablePublisher, PublisherDurableObject, ResumeStorage };
+export type { DurablePublisherOptions, PublisherDurableObjectOptions, ResumeStorageOptions, SerializedMessage };

package/dist/index.d.ts

@@ -0,0 +1,108 @@
+import { DurableObject } from 'cloudflare:workers';
+import { StandardRPCJsonSerializerOptions } from '@orpc/client/standard';
+import { PublisherOptions, Publisher, PublisherSubscribeListenerOptions } from '@orpc/experimental-publisher';
+import { EventMeta } from '@orpc/standard-server';
+
+interface ResumeStorageOptions {
+    /**
+     * How long (in seconds) to retain events for replay.
+     *
+     * When a client reconnects, stored events within this window can be replayed
+     * to ensure no data is lost. Outside this window, missed events are dropped.
+     *
+     * @remarks
+     * - Use 0, negative or infinite numbers to disable resume functionality
+     * - Event cleanup is deferred for performance reasons — expired events may
+     *   remain briefly beyond their retention time
+     *
+     * @default 0 (disabled)
+     */
+    retentionSeconds?: number;
+    /**
+     * How long (in seconds) of inactivity before auto-deleting the durable object's data.
+     * Inactivity means no active WebSocket connections and no events within the retention period.
+     *
+     * The alarm is scheduled at `retentionSeconds + inactiveDataRetentionTime`.
+     *
+     * @default 6 * 60 * 60 (6 hours)
+     */
+    inactiveDataRetentionTime?: number;
+    /**
+     * Prefix for the resume storage table schema.
+     * Used to avoid naming conflicts with other tables in the same Durable Object.
+     *
+     * @default 'orpc:publisher:resume:'
+     */
+    schemaPrefix?: string;
+}
+declare class ResumeStorage {
+    private readonly ctx;
+    private readonly retentionSeconds;
+    private readonly inactiveDataRetentionTime;
+    private readonly schemaPrefix;
+    private isInitedSchema;
+    private isInitedAlarm;
+    private lastCleanupTime;
+    get isEnabled(): boolean;
+    constructor(ctx: DurableObjectState, options?: ResumeStorageOptions);
+    /**
+     * Store an event and return the updated serialized message with an assigned ID.
+     */
+    store(stringified: string): Promise<string>;
+    /**
+     * Get all events after the specified lastEventId, ordered by ID ascending.
+     */
+    getEventsAfter(lastEventId: string): Promise<string[]>;
+    /**
+     * Auto-delete durable object data if inactive for extended period.
+     * Inactivity means: no active connections AND no active events.
+     */
+    alarm(): Promise<void>;
+    private ensureReady;
+    private resetData;
+    private scheduleAlarm;
+}
+
+interface PublisherDurableObjectOptions {
+    resume?: ResumeStorageOptions;
+}
+declare class PublisherDurableObject<Env = Cloudflare.Env, Props = {}> extends DurableObject<Env, Props> {
+    private readonly resumeStorage;
+    constructor(ctx: DurableObjectState<Props>, env: Env, options?: PublisherDurableObjectOptions);
+    fetch(request: Request): Promise<Response>;
+    private handlePublish;
+    private handleSubscribe;
+    alarm(): Promise<void>;
+}
+
+interface DurablePublisherOptions extends PublisherOptions, StandardRPCJsonSerializerOptions {
+    /**
+     * Prefix for events, to avoid naming conflicts with other publishers in the same Durable Object.
+     *
+     * @default ''
+     */
+    prefix?: string;
+    /**
+     * Custom function to get the Durable Object stub for publishing.
+     *
+     * @default ((namespace, event) => namespace.getByName(event))
+     */
+    getStubByName?: (namespace: DurableObjectNamespace, event: string) => DurableObjectStub;
+}
+declare class DurablePublisher<T extends Record<string, object>> extends Publisher<T> {
+    private readonly namespace;
+    private readonly prefix;
+    private readonly serializer;
+    private readonly getStubByName;
+    constructor(namespace: DurableObjectNamespace, { prefix, getStubByName, ...options }?: DurablePublisherOptions);
+    publish<K extends keyof T & string>(event: K, payload: T[K]): Promise<void>;
+    protected subscribeListener<K extends keyof T & string>(event: K, listener: (payload: T[K]) => void, options?: PublisherSubscribeListenerOptions): Promise<() => Promise<void>>;
+}
+
+interface SerializedMessage {
+    data: unknown;
+    meta?: EventMeta;
+}
+
+export { DurablePublisher, PublisherDurableObject, ResumeStorage };
+export type { DurablePublisherOptions, PublisherDurableObjectOptions, ResumeStorageOptions, SerializedMessage };

package/dist/index.mjs

@@ -0,0 +1,278 @@
+import { DurableObject } from 'cloudflare:workers';
+import { stringifyJSON, isTypescriptObject } from '@orpc/shared';
+import { StandardRPCJsonSerializer } from '@orpc/client/standard';
+import { Publisher } from '@orpc/experimental-publisher';
+import { getEventMeta, withEventMeta } from '@orpc/standard-server';
+
+class ResumeStorage {
+  constructor(ctx, options = {}) {
+    this.ctx = ctx;
+    this.retentionSeconds = options.retentionSeconds ?? 0;
+    this.inactiveDataRetentionTime = options.inactiveDataRetentionTime ?? 6 * 60 * 60;
+    this.schemaPrefix = options.schemaPrefix ?? "orpc:publisher:resume:";
+  }
+  retentionSeconds;
+  inactiveDataRetentionTime;
+  schemaPrefix;
+  isInitedSchema = false;
+  isInitedAlarm = false;
+  lastCleanupTime;
+  get isEnabled() {
+    return Number.isFinite(this.retentionSeconds) && this.retentionSeconds > 0;
+  }
+  /**
+   * Store an event and return the updated serialized message with an assigned ID.
+   */
+  async store(stringified) {
+    if (!this.isEnabled) {
+      return stringified;
+    }
+    await this.ensureReady();
+    const message = JSON.parse(stringified);
+    const insertEvent = () => {
+      const result = this.ctx.storage.sql.exec(
+        `INSERT INTO "${this.schemaPrefix}events" (payload) VALUES (?) RETURNING CAST(id AS TEXT) as id`,
+        stringified
+      );
+      const id = result.one()?.id;
+      const updatedIdMessage = {
+        ...message,
+        meta: { ...message.meta, id }
+      };
+      return stringifyJSON(updatedIdMessage);
+    };
+    try {
+      return insertEvent();
+    } catch {
+      await this.resetData();
+      return insertEvent();
+    }
+  }
+  /**
+   * Get all events after the specified lastEventId, ordered by ID ascending.
+   */
+  async getEventsAfter(lastEventId) {
+    if (!this.isEnabled) {
+      return [];
+    }
+    await this.ensureReady();
+    const result = this.ctx.storage.sql.exec(`
+      SELECT CAST(id AS TEXT) as id, payload
+      FROM "${this.schemaPrefix}events"
+      WHERE id > ?
+      ORDER BY id ASC
+    `, lastEventId);
+    const events = [];
+    for (const record of result.toArray()) {
+      const message = JSON.parse(record.payload);
+      const updatedIdMessage = {
+        ...message,
+        meta: { ...message.meta, id: record.id }
+      };
+      events.push(stringifyJSON(updatedIdMessage));
+    }
+    return events;
+  }
+  /**
+   * Auto-delete durable object data if inactive for extended period.
+   * Inactivity means: no active connections AND no active events.
+   */
+  async alarm() {
+    this.isInitedAlarm = true;
+    await this.ensureReady();
+    const hasActiveWebSockets = this.ctx.getWebSockets().length > 0;
+    if (hasActiveWebSockets) {
+      await this.scheduleAlarm();
+      return;
+    }
+    const activeEventsCount = this.ctx.storage.sql.exec(`
+      SELECT COUNT(*) as count
+      FROM "${this.schemaPrefix}events"
+    `);
+    const hasActiveEvents = activeEventsCount.one()?.count > 0;
+    if (hasActiveEvents) {
+      await this.scheduleAlarm();
+      return;
+    }
+    await this.ctx.blockConcurrencyWhile(async () => {
+      this.isInitedSchema = false;
+      this.isInitedAlarm = false;
+      await this.ctx.storage.deleteAll();
+    });
+  }
+  async ensureReady() {
+    if (this.isInitedSchema) {
+      const now = Date.now();
+      if (this.lastCleanupTime && this.lastCleanupTime + this.retentionSeconds * 1e3 > now) {
+        return;
+      }
+      this.lastCleanupTime = now;
+      this.ctx.storage.sql.exec(`
+        DELETE FROM "${this.schemaPrefix}events" WHERE stored_at < unixepoch() - ?
+      `, this.retentionSeconds);
+      return;
+    }
+    const result = this.ctx.storage.sql.exec(`
+      CREATE TABLE IF NOT EXISTS "${this.schemaPrefix}events" (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        payload TEXT NOT NULL,
+        stored_at INTEGER NOT NULL DEFAULT (unixepoch())
+      )
+    `);
+    this.ctx.storage.sql.exec(`
+      CREATE INDEX IF NOT EXISTS "${this.schemaPrefix}idx_events_id" ON "${this.schemaPrefix}events" (id)
+    `);
+    this.ctx.storage.sql.exec(`
+      CREATE INDEX IF NOT EXISTS "${this.schemaPrefix}idx_events_stored_at" ON "${this.schemaPrefix}events" (stored_at)
+    `);
+    this.isInitedSchema = true;
+    if (!this.isInitedAlarm || result.rowsWritten > 0) {
+      await this.scheduleAlarm();
+      this.isInitedAlarm = true;
+    }
+  }
+  async resetData() {
+    this.ctx.storage.sql.exec(`DROP TABLE IF EXISTS "${this.schemaPrefix}events"`);
+    this.isInitedSchema = false;
+    await this.ensureReady();
+  }
+  scheduleAlarm() {
+    return this.ctx.storage.setAlarm(Date.now() + (this.retentionSeconds + this.inactiveDataRetentionTime) * 1e3);
+  }
+}
+
+class PublisherDurableObject extends DurableObject {
+  resumeStorage;
+  constructor(ctx, env, options = {}) {
+    super(ctx, env);
+    this.resumeStorage = new ResumeStorage(ctx, options.resume);
+  }
+  fetch(request) {
+    if (request.url.includes("/publish")) {
+      return this.handlePublish(request);
+    }
+    return this.handleSubscribe(request);
+  }
+  async handlePublish(request) {
+    const message = await this.resumeStorage.store(
+      await request.text()
+    );
+    for (const ws of this.ctx.getWebSockets()) {
+      try {
+        ws.send(message);
+      } catch (e) {
+        console.error("Failed to send message to websocket:", e);
+      }
+    }
+    return new Response(null, { status: 204 });
+  }
+  async handleSubscribe(request) {
+    const { "0": client, "1": server } = new WebSocketPair();
+    this.ctx.acceptWebSocket(server);
+    const lastEventId = request.headers.get("last-event-id");
+    if (lastEventId !== null) {
+      const events = await this.resumeStorage.getEventsAfter(lastEventId);
+      for (const event of events) {
+        try {
+          server.send(event);
+        } catch (e) {
+          console.error("Failed to replay event to websocket:", e);
+        }
+      }
+    }
+    return new Response(null, { status: 101, webSocket: client });
+  }
+  async alarm() {
+    await this.resumeStorage.alarm();
+  }
+}
+
+class DurablePublisher extends Publisher {
+  constructor(namespace, { prefix, getStubByName, ...options } = {}) {
+    super(options);
+    this.namespace = namespace;
+    this.prefix = prefix ?? "";
+    this.serializer = new StandardRPCJsonSerializer(options);
+    this.getStubByName = getStubByName ?? ((namespace2, event) => namespace2.getByName(event));
+  }
+  prefix;
+  serializer;
+  getStubByName;
+  async publish(event, payload) {
+    const stub = this.getStubByName(this.namespace, this.prefix + event);
+    const [json_, meta_] = this.serializer.serialize(payload);
+    const serialized = {
+      data: { json: json_, meta: meta_ },
+      meta: getEventMeta(payload)
+    };
+    const response = await stub.fetch(new Request("http://localhost/publish", {
+      method: "POST",
+      body: stringifyJSON(serialized)
+    }));
+    if (!response.ok) {
+      throw new Error(`Failed to publish event: ${response.status} ${response.statusText}`, {
+        cause: response
+      });
+    }
+  }
+  async subscribeListener(event, listener, options) {
+    const stub = this.getStubByName(this.namespace, this.prefix + event);
+    const headers = new Headers({ upgrade: "websocket" });
+    if (options?.lastEventId !== void 0) {
+      headers.set("last-event-id", options.lastEventId);
+    }
+    const response = await stub.fetch("http://localhost/subscribe", {
+      headers
+    });
+    const websocket = response.webSocket;
+    if (!websocket) {
+      throw new Error("Failed to open subscription websocket to publisher durable object", {
+        cause: response
+      });
+    }
+    websocket.addEventListener("message", async (event2) => {
+      try {
+        let data;
+        if (event2.data instanceof Blob) {
+          data = await event2.data.text();
+        } else if (typeof event2.data === "string") {
+          data = event2.data;
+        } else {
+          data = new TextDecoder().decode(event2.data);
+        }
+        const serialized = JSON.parse(data);
+        const payload = this.serializer.deserialize(serialized.data.json, serialized.data.meta);
+        const payloadWithMeta = isTypescriptObject(payload) && serialized.meta ? withEventMeta(payload, serialized.meta) : payload;
+        listener(payloadWithMeta);
+      } catch (error) {
+        options?.onError?.(
+          new Error("Failed to deserialize message from publisher durable object", {
+            cause: error
+          })
+        );
+      }
+    });
+    websocket.addEventListener("close", (event2) => {
+      if (event2.code !== 1e3 && event2.code !== 1001) {
+        options?.onError?.(
+          new Error(`WebSocket closed unexpectedly: ${event2.code} ${event2.reason}`, {
+            cause: event2
+          })
+        );
+      }
+    });
+    websocket.addEventListener("error", (event2) => {
+      options?.onError?.(
+        new Error(`Subscription websocket error`, {
+          cause: event2
+        })
+      );
+    });
+    websocket.accept();
+    return async () => {
+      websocket.close();
+    };
+  }
+}
+
+export { DurablePublisher, PublisherDurableObject, ResumeStorage };

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@orpc/experimental-publisher-durable-object",
+  "type": "module",
+  "version": "0.0.0",
+  "license": "MIT",
+  "homepage": "https://orpc.unnoq.com",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/unnoq/orpc.git",
+    "directory": "packages/publisher-durable-object"
+  },
+  "keywords": [
+    "unnoq",
+    "orpc"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.mts",
+      "import": "./dist/index.mjs",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@orpc/client": "1.11.3",
+    "@orpc/experimental-publisher": "1.11.3",
+    "@orpc/shared": "1.11.3",
+    "@orpc/standard-server": "1.11.3"
+  },
+  "devDependencies": {
+    "@cloudflare/workers-types": "^4.20251118.0",
+    "@types/node": "^22.15.30",
+    "@orpc/standard-server-peer": "1.11.3"
+  },
+  "scripts": {
+    "build": "unbuild",
+    "build:watch": "pnpm run build --watch",
+    "type:check": "tsc -b",
+    "type:check:test": "tsc -p tsconfig.test.json --noEmit"
+  }
+}