@orpc/experimental-durable-iterator 0.0.0-next.01f0b7a

package/dist/index.d.ts

@@ -0,0 +1,85 @@
+import * as _orpc_contract from '@orpc/contract';
+import { AsyncIteratorClass } from '@orpc/shared';
+import * as v from 'valibot';
+import { C as ClientDurableIterator } from './shared/experimental-durable-iterator.C6YPLbUA.js';
+import { D as DurableIteratorObject, I as InferDurableIteratorObjectRPC } from './shared/experimental-durable-iterator.DQjHfIr1.js';
+export { a as DurableIteratorObjectDef, b as DurableIteratorTokenPayload, p as parseDurableIteratorToken, s as signDurableIteratorToken, v as verifyDurableIteratorToken } from './shared/experimental-durable-iterator.DQjHfIr1.js';
+import { Context, Router } from '@orpc/server';
+import { StandardHandlerPlugin, StandardHandlerOptions } from '@orpc/server/standard';
+import '@orpc/client';
+import '@orpc/client/plugins';
+
+declare const DURABLE_ITERATOR_TOKEN_PARAM: "token";
+declare const DURABLE_ITERATOR_ID_PARAM: "id";
+declare const DURABLE_ITERATOR_PLUGIN_HEADER_KEY: "x-orpc-dei";
+declare const DURABLE_ITERATOR_PLUGIN_HEADER_VALUE: "1";
+
+declare const durableIteratorContract: {
+    updateToken: _orpc_contract.ContractProcedureBuilderWithInput<v.ObjectSchema<{
+        readonly token: v.StringSchema<undefined>;
+    }, undefined>, _orpc_contract.Schema<unknown, unknown>, Record<never, never>, Record<never, never>>;
+    subscribe: _orpc_contract.ContractProcedureBuilderWithOutput<_orpc_contract.Schema<unknown, unknown>, _orpc_contract.Schema<AsyncIteratorClass<any, unknown, unknown>, AsyncIteratorClass<any, unknown, unknown>>, Record<never, never>, Record<never, never>>;
+    call: _orpc_contract.ContractProcedureBuilderWithInput<v.ObjectSchema<{
+        readonly path: v.TupleWithRestSchema<[v.StringSchema<undefined>], v.StringSchema<undefined>, undefined>;
+        readonly input: v.UnknownSchema;
+    }, undefined>, _orpc_contract.Schema<unknown, unknown>, Record<never, never>, Record<never, never>>;
+};
+
+declare class DurableIteratorError extends Error {
+}
+
+interface DurableIteratorOptions<T extends DurableIteratorObject<any>, RPC extends InferDurableIteratorObjectRPC<T>> {
+    /**
+     * The  signing key used to sign the token
+     */
+    signingKey: string;
+    /**
+     * Time to live for the token in seconds.
+     * After expiration, the token will no longer be valid.
+     *
+     * @default 24 hours (60 * 60 * 24)
+     */
+    tokenTTLSeconds?: number;
+    /**
+     * Tags to attach to the token.
+     */
+    tags?: readonly string[];
+    /**
+     * Token's attachment
+     */
+    att?: unknown;
+    /**
+     * The methods that are allowed to be called remotely.
+     *
+     * @warning Please use .rpc method to set this field in case ts complains about value you pass
+     */
+    rpc?: readonly RPC[];
+}
+declare class DurableIterator<T extends DurableIteratorObject<any>, RPC extends InferDurableIteratorObjectRPC<T> = never> implements PromiseLike<ClientDurableIterator<T, RPC>> {
+    private readonly chn;
+    private readonly options;
+    constructor(chn: string, options: DurableIteratorOptions<T, RPC>);
+    /**
+     * List of methods that are allowed to be called remotely.
+     */
+    rpc<U extends InferDurableIteratorObjectRPC<T>>(...rpc: U[]): Omit<DurableIterator<T, U>, 'rpc'>;
+    then<TResult1 = ClientDurableIterator<T, RPC>, TResult2 = never>(onfulfilled?: ((value: ClientDurableIterator<T, RPC>) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null | undefined): PromiseLike<TResult1 | TResult2>;
+}
+
+interface DurableIteratorHandlerPluginContext {
+    isClientDurableIteratorOutput?: boolean;
+}
+/**
+ * @see {@link https://orpc.unnoq.com/docs/integrations/durable-iterator Durable Iterator Integration}
+ */
+declare class DurableIteratorHandlerPlugin<T extends Context> implements StandardHandlerPlugin<T> {
+    readonly CONTEXT_SYMBOL: symbol;
+    /**
+     * make sure run after batch plugin
+     */
+    order: number;
+    init(options: StandardHandlerOptions<T>, _router: Router<any, T>): void;
+}
+
+export { DURABLE_ITERATOR_ID_PARAM, DURABLE_ITERATOR_PLUGIN_HEADER_KEY, DURABLE_ITERATOR_PLUGIN_HEADER_VALUE, DURABLE_ITERATOR_TOKEN_PARAM, DurableIterator, DurableIteratorError, DurableIteratorHandlerPlugin, DurableIteratorObject, InferDurableIteratorObjectRPC, durableIteratorContract };
+export type { DurableIteratorHandlerPluginContext, DurableIteratorOptions };

package/dist/index.mjs

@@ -0,0 +1,105 @@
+import { s as signDurableIteratorToken, D as DurableIteratorError, a as DURABLE_ITERATOR_PLUGIN_HEADER_VALUE, b as DURABLE_ITERATOR_PLUGIN_HEADER_KEY } from './shared/experimental-durable-iterator.DZOLL3sf.mjs';
+export { d as DURABLE_ITERATOR_ID_PARAM, c as DURABLE_ITERATOR_TOKEN_PARAM, p as parseDurableIteratorToken, v as verifyDurableIteratorToken } from './shared/experimental-durable-iterator.DZOLL3sf.mjs';
+export { d as durableIteratorContract } from './shared/experimental-durable-iterator.BRB0hiXN.mjs';
+import { AsyncIteratorClass } from '@orpc/shared';
+import { c as createClientDurableIterator, g as getClientDurableIteratorToken } from './shared/experimental-durable-iterator.B3M42lLK.mjs';
+import '@orpc/client';
+import '@orpc/client/plugins';
+import '@orpc/client/websocket';
+import 'partysocket';
+import '@orpc/server/helpers';
+import 'valibot';
+import '@orpc/contract';
+
+class DurableIterator {
+  constructor(chn, options) {
+    this.chn = chn;
+    this.options = options;
+  }
+  /**
+   * List of methods that are allowed to be called remotely.
+   */
+  rpc(...rpc) {
+    return new DurableIterator(this.chn, {
+      ...this.options,
+      rpc
+    });
+  }
+  then(onfulfilled, onrejected) {
+    return (async () => {
+      const tokenTTLSeconds = this.options.tokenTTLSeconds ?? 60 * 60 * 24;
+      const nowInSeconds = Math.floor(Date.now() / 1e3);
+      const token = await signDurableIteratorToken(this.options.signingKey, {
+        chn: this.chn,
+        tags: this.options.tags,
+        att: this.options.att,
+        rpc: this.options.rpc,
+        iat: nowInSeconds,
+        exp: nowInSeconds + tokenTTLSeconds
+      });
+      const iterator = new AsyncIteratorClass(
+        () => Promise.reject(new DurableIteratorError("Cannot be iterated directly.")),
+        () => Promise.reject(new DurableIteratorError("Cannot be cleaned up directly."))
+      );
+      const link = {
+        call() {
+          throw new DurableIteratorError("Cannot call methods directly.");
+        }
+      };
+      const durableIterator = createClientDurableIterator(iterator, link, {
+        getToken: () => token
+      });
+      return durableIterator;
+    })().then(onfulfilled, onrejected);
+  }
+}
+
+class DurableIteratorHandlerPlugin {
+  CONTEXT_SYMBOL = Symbol("ORPC_DURABLE_ITERATOR_HANDLER_PLUGIN_CONTEXT");
+  /**
+   * make sure run after batch plugin
+   */
+  order = 15e5;
+  init(options, _router) {
+    options.interceptors ??= [];
+    options.clientInterceptors ??= [];
+    options.interceptors.unshift(async (options2) => {
+      const pluginContext = {};
+      const result = await options2.next({
+        ...options2,
+        context: {
+          [this.CONTEXT_SYMBOL]: pluginContext,
+          ...options2.context
+        }
+      });
+      if (!result.matched) {
+        return result;
+      }
+      return {
+        ...result,
+        response: {
+          ...result.response,
+          headers: {
+            ...result.response.headers,
+            [DURABLE_ITERATOR_PLUGIN_HEADER_KEY]: pluginContext.isClientDurableIteratorOutput ? DURABLE_ITERATOR_PLUGIN_HEADER_VALUE : void 0
+          }
+        }
+      };
+    });
+    options.clientInterceptors.unshift(async (options2) => {
+      const pluginContext = options2.context[this.CONTEXT_SYMBOL];
+      if (!pluginContext) {
+        throw new DurableIteratorError("Plugin context has been corrupted or modified by another plugin or interceptor");
+      }
+      const output = await options2.next();
+      const token = getClientDurableIteratorToken(output);
+      if (typeof token === "string") {
+        pluginContext.isClientDurableIteratorOutput = true;
+        return token;
+      }
+      return output;
+    });
+  }
+}
+
+export { DURABLE_ITERATOR_PLUGIN_HEADER_KEY, DURABLE_ITERATOR_PLUGIN_HEADER_VALUE, DurableIterator, DurableIteratorError, DurableIteratorHandlerPlugin, signDurableIteratorToken };

package/dist/shared/experimental-durable-iterator.B3M42lLK.mjs

@@ -0,0 +1,29 @@
+import { createORPCClient } from '@orpc/client';
+import { isAsyncIteratorObject } from '@orpc/shared';
+import { p as parseDurableIteratorToken } from './experimental-durable-iterator.DZOLL3sf.mjs';
+
+const CLIENT_DURABLE_ITERATOR_TOKEN_SYMBOL = Symbol("ORPC_CLIENT_DURABLE_ITERATOR_TOKEN");
+function createClientDurableIterator(iterator, link, options) {
+  const proxy = new Proxy(iterator, {
+    get(target, prop) {
+      const token = options.getToken();
+      const { rpc: allowMethods } = parseDurableIteratorToken(token);
+      if (prop === CLIENT_DURABLE_ITERATOR_TOKEN_SYMBOL) {
+        return token;
+      }
+      if (typeof prop === "string" && allowMethods?.includes(prop)) {
+        return createORPCClient(link, { path: [prop] });
+      }
+      const v = Reflect.get(target, prop);
+      return typeof v === "function" ? v.bind(target) : v;
+    }
+  });
+  return proxy;
+}
+function getClientDurableIteratorToken(client) {
+  if (isAsyncIteratorObject(client)) {
+    return Reflect.get(client, CLIENT_DURABLE_ITERATOR_TOKEN_SYMBOL);
+  }
+}
+
+export { createClientDurableIterator as c, getClientDurableIteratorToken as g };

package/dist/shared/experimental-durable-iterator.BRB0hiXN.mjs

@@ -0,0 +1,15 @@
+import { oc, type } from '@orpc/contract';
+import * as v from 'valibot';
+
+const durableIteratorContract = {
+  updateToken: oc.input(v.object({ token: v.string() })).route({ summary: "Update old token with a new one, usually before it expires" }),
+  subscribe: oc.route({ summary: "Listen to durable iterator events" }).output(type()),
+  call: oc.route({ summary: "Call a remote method" }).input(
+    v.object({
+      path: v.tupleWithRest([v.string()], v.string()),
+      input: v.unknown()
+    })
+  )
+};
+
+export { durableIteratorContract as d };

package/dist/shared/experimental-durable-iterator.C6YPLbUA.d.ts

@@ -0,0 +1,28 @@
+import { NestedClient, Client, ThrowableError, ClientLink } from '@orpc/client';
+import { ClientRetryPluginContext } from '@orpc/client/plugins';
+import { AsyncIteratorClass } from '@orpc/shared';
+import { D as DurableIteratorObject, I as InferDurableIteratorObjectRPC } from './experimental-durable-iterator.DQjHfIr1.js';
+
+interface ClientDurableIteratorRpcContext extends ClientRetryPluginContext {
+}
+type ClientDurableIteratorRpc<T extends NestedClient<object>> = T extends Client<any, infer UInput, infer UOutput, any> ? Client<ClientDurableIteratorRpcContext, UInput, UOutput, ThrowableError> : {
+    [K in keyof T]: T[K] extends NestedClient<object> ? ClientDurableIteratorRpc<T[K]> : never;
+};
+type ClientDurableIterator<T extends DurableIteratorObject<any>, RPC extends InferDurableIteratorObjectRPC<T>> = AsyncIteratorClass<T extends DurableIteratorObject<infer TPayload> ? TPayload : never> & {
+    [K in RPC]: T[K] extends (...args: any[]) => (infer R extends NestedClient<object>) ? ClientDurableIteratorRpc<R> : never;
+};
+interface CreateClientDurableIteratorOptions {
+    /**
+     * The token used to authenticate the client.
+     * this is a function because the token is lazy, and dynamic-able
+     */
+    getToken: () => string;
+}
+declare function createClientDurableIterator<T extends DurableIteratorObject<any>, RPC extends InferDurableIteratorObjectRPC<T>>(iterator: AsyncIteratorClass<T>, link: ClientLink<object>, options: CreateClientDurableIteratorOptions): ClientDurableIterator<T, RPC>;
+/**
+ * If return a token if the client is a Client Durable Iterator.
+ */
+declare function getClientDurableIteratorToken(client: unknown): string | undefined;
+
+export { createClientDurableIterator as d, getClientDurableIteratorToken as g };
+export type { ClientDurableIterator as C, ClientDurableIteratorRpcContext as a, ClientDurableIteratorRpc as b, CreateClientDurableIteratorOptions as c };

package/dist/shared/experimental-durable-iterator.DQjHfIr1.d.mts

@@ -0,0 +1,42 @@
+import { NestedClient } from '@orpc/client';
+import { AsyncIteratorClass } from '@orpc/shared';
+import * as v from 'valibot';
+
+interface DurableIteratorObjectDef<T extends object> {
+    '~eventPayloadType'?: {
+        type: T;
+    };
+}
+interface DurableIteratorObject<T extends object> {
+    '~orpc'?: DurableIteratorObjectDef<T>;
+}
+type InferDurableIteratorObjectRPC<T extends DurableIteratorObject<any>> = Exclude<{
+    [K in keyof T]: T[K] extends ((...args: any[]) => NestedClient<object>) ? K : never;
+}[keyof T], keyof AsyncIteratorClass<any>> & string;
+
+type DurableIteratorTokenPayload = v.InferOutput<typeof DurableIteratorTokenPayloadSchema>;
+declare const DurableIteratorTokenPayloadSchema: v.ObjectSchema<{
+    readonly chn: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Channel name">]>;
+    readonly tags: v.SchemaWithPipe<readonly [v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>, v.ReadonlyAction<string[] | undefined>, v.DescriptionAction<readonly string[] | undefined, "Tags">]>;
+    readonly att: v.SchemaWithPipe<readonly [v.OptionalSchema<v.UnknownSchema, undefined>, v.DescriptionAction<unknown, "Attachment">]>;
+    readonly rpc: v.SchemaWithPipe<readonly [v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>, v.ReadonlyAction<string[] | undefined>, v.DescriptionAction<readonly string[] | undefined, "Allowed remote methods">]>;
+    readonly iat: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "Issued at time in seconds">]>;
+    readonly exp: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "Expiration time in seconds">]>;
+}, undefined>;
+/**
+ * Signs and encodes a token payload.
+ */
+declare function signDurableIteratorToken(secret: string, payload: DurableIteratorTokenPayload): Promise<string>;
+/**
+ * Verifies a token and returns the payload if valid.
+ */
+declare function verifyDurableIteratorToken(secret: string, token: string): Promise<DurableIteratorTokenPayload | undefined>;
+/**
+ * Extracts the payload from a token without verifying its signature.
+ *
+ * @throws if invalid format
+ */
+declare function parseDurableIteratorToken(token: string | null | undefined): DurableIteratorTokenPayload;
+
+export { parseDurableIteratorToken as p, signDurableIteratorToken as s, verifyDurableIteratorToken as v };
+export type { DurableIteratorObject as D, InferDurableIteratorObjectRPC as I, DurableIteratorObjectDef as a, DurableIteratorTokenPayload as b };

package/dist/shared/experimental-durable-iterator.DQjHfIr1.d.ts

@@ -0,0 +1,42 @@
+import { NestedClient } from '@orpc/client';
+import { AsyncIteratorClass } from '@orpc/shared';
+import * as v from 'valibot';
+
+interface DurableIteratorObjectDef<T extends object> {
+    '~eventPayloadType'?: {
+        type: T;
+    };
+}
+interface DurableIteratorObject<T extends object> {
+    '~orpc'?: DurableIteratorObjectDef<T>;
+}
+type InferDurableIteratorObjectRPC<T extends DurableIteratorObject<any>> = Exclude<{
+    [K in keyof T]: T[K] extends ((...args: any[]) => NestedClient<object>) ? K : never;
+}[keyof T], keyof AsyncIteratorClass<any>> & string;
+
+type DurableIteratorTokenPayload = v.InferOutput<typeof DurableIteratorTokenPayloadSchema>;
+declare const DurableIteratorTokenPayloadSchema: v.ObjectSchema<{
+    readonly chn: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.DescriptionAction<string, "Channel name">]>;
+    readonly tags: v.SchemaWithPipe<readonly [v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>, v.ReadonlyAction<string[] | undefined>, v.DescriptionAction<readonly string[] | undefined, "Tags">]>;
+    readonly att: v.SchemaWithPipe<readonly [v.OptionalSchema<v.UnknownSchema, undefined>, v.DescriptionAction<unknown, "Attachment">]>;
+    readonly rpc: v.SchemaWithPipe<readonly [v.OptionalSchema<v.ArraySchema<v.StringSchema<undefined>, undefined>, undefined>, v.ReadonlyAction<string[] | undefined>, v.DescriptionAction<readonly string[] | undefined, "Allowed remote methods">]>;
+    readonly iat: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "Issued at time in seconds">]>;
+    readonly exp: v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.DescriptionAction<number, "Expiration time in seconds">]>;
+}, undefined>;
+/**
+ * Signs and encodes a token payload.
+ */
+declare function signDurableIteratorToken(secret: string, payload: DurableIteratorTokenPayload): Promise<string>;
+/**
+ * Verifies a token and returns the payload if valid.
+ */
+declare function verifyDurableIteratorToken(secret: string, token: string): Promise<DurableIteratorTokenPayload | undefined>;
+/**
+ * Extracts the payload from a token without verifying its signature.
+ *
+ * @throws if invalid format
+ */
+declare function parseDurableIteratorToken(token: string | null | undefined): DurableIteratorTokenPayload;
+
+export { parseDurableIteratorToken as p, signDurableIteratorToken as s, verifyDurableIteratorToken as v };
+export type { DurableIteratorObject as D, InferDurableIteratorObjectRPC as I, DurableIteratorObjectDef as a, DurableIteratorTokenPayload as b };

package/dist/shared/experimental-durable-iterator.DZOLL3sf.mjs

@@ -0,0 +1,47 @@
+import { unsign, sign, getSignedValue } from '@orpc/server/helpers';
+import { parseEmptyableJSON, stringifyJSON } from '@orpc/shared';
+import * as v from 'valibot';
+
+const DURABLE_ITERATOR_TOKEN_PARAM = "token";
+const DURABLE_ITERATOR_ID_PARAM = "id";
+const DURABLE_ITERATOR_PLUGIN_HEADER_KEY = "x-orpc-dei";
+const DURABLE_ITERATOR_PLUGIN_HEADER_VALUE = "1";
+
+class DurableIteratorError extends Error {
+}
+
+const DurableIteratorTokenPayloadSchema = v.object({
+  chn: v.pipe(v.string(), v.description("Channel name")),
+  tags: v.pipe(v.optional(v.array(v.string())), v.readonly(), v.description("Tags")),
+  att: v.pipe(v.optional(v.unknown()), v.description("Attachment")),
+  rpc: v.pipe(v.optional(v.array(v.string())), v.readonly(), v.description("Allowed remote methods")),
+  iat: v.pipe(v.number(), v.description("Issued at time in seconds")),
+  exp: v.pipe(v.number(), v.description("Expiration time in seconds"))
+});
+function signDurableIteratorToken(secret, payload) {
+  return sign(stringifyJSON(payload), secret);
+}
+async function verifyDurableIteratorToken(secret, token) {
+  try {
+    const payload = parseEmptyableJSON(await unsign(token, secret));
+    if (!v.is(DurableIteratorTokenPayloadSchema, payload)) {
+      return void 0;
+    }
+    if (payload.exp < Date.now() / 1e3) {
+      return void 0;
+    }
+    return payload;
+  } catch {
+    return void 0;
+  }
+}
+function parseDurableIteratorToken(token) {
+  try {
+    const payload = parseEmptyableJSON(getSignedValue(token));
+    return v.parse(DurableIteratorTokenPayloadSchema, payload);
+  } catch (error) {
+    throw new DurableIteratorError("Invalid token payload", { cause: error });
+  }
+}
+
+export { DurableIteratorError as D, DURABLE_ITERATOR_PLUGIN_HEADER_VALUE as a, DURABLE_ITERATOR_PLUGIN_HEADER_KEY as b, DURABLE_ITERATOR_TOKEN_PARAM as c, DURABLE_ITERATOR_ID_PARAM as d, parseDurableIteratorToken as p, signDurableIteratorToken as s, verifyDurableIteratorToken as v };

package/dist/shared/experimental-durable-iterator.DrenXxND.d.mts

@@ -0,0 +1,28 @@
+import { NestedClient, Client, ThrowableError, ClientLink } from '@orpc/client';
+import { ClientRetryPluginContext } from '@orpc/client/plugins';
+import { AsyncIteratorClass } from '@orpc/shared';
+import { D as DurableIteratorObject, I as InferDurableIteratorObjectRPC } from './experimental-durable-iterator.DQjHfIr1.mjs';
+
+interface ClientDurableIteratorRpcContext extends ClientRetryPluginContext {
+}
+type ClientDurableIteratorRpc<T extends NestedClient<object>> = T extends Client<any, infer UInput, infer UOutput, any> ? Client<ClientDurableIteratorRpcContext, UInput, UOutput, ThrowableError> : {
+    [K in keyof T]: T[K] extends NestedClient<object> ? ClientDurableIteratorRpc<T[K]> : never;
+};
+type ClientDurableIterator<T extends DurableIteratorObject<any>, RPC extends InferDurableIteratorObjectRPC<T>> = AsyncIteratorClass<T extends DurableIteratorObject<infer TPayload> ? TPayload : never> & {
+    [K in RPC]: T[K] extends (...args: any[]) => (infer R extends NestedClient<object>) ? ClientDurableIteratorRpc<R> : never;
+};
+interface CreateClientDurableIteratorOptions {
+    /**
+     * The token used to authenticate the client.
+     * this is a function because the token is lazy, and dynamic-able
+     */
+    getToken: () => string;
+}
+declare function createClientDurableIterator<T extends DurableIteratorObject<any>, RPC extends InferDurableIteratorObjectRPC<T>>(iterator: AsyncIteratorClass<T>, link: ClientLink<object>, options: CreateClientDurableIteratorOptions): ClientDurableIterator<T, RPC>;
+/**
+ * If return a token if the client is a Client Durable Iterator.
+ */
+declare function getClientDurableIteratorToken(client: unknown): string | undefined;
+
+export { createClientDurableIterator as d, getClientDurableIteratorToken as g };
+export type { ClientDurableIterator as C, ClientDurableIteratorRpcContext as a, ClientDurableIteratorRpc as b, CreateClientDurableIteratorOptions as c };

package/package.json

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