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

package/dist/durable-object/index.mjs

@@ -0,0 +1,536 @@
+import { getEventMeta, withEventMeta, implement, ORPCError } from '@orpc/server';
+export { withEventMeta } from '@orpc/server';
+import { HibernationEventIterator, encodeHibernationRPCEvent, HibernationPlugin } from '@orpc/server/hibernation';
+import { RPCHandler } from '@orpc/server/websocket';
+import { fallback, parseEmptyableJSON, stringifyJSON, get, toArray, intercept } from '@orpc/shared';
+import { D as DurableIteratorError, v as verifyDurableIteratorToken, c as DURABLE_ITERATOR_TOKEN_PARAM, d as DURABLE_ITERATOR_ID_PARAM } from '../shared/experimental-durable-iterator.DZOLL3sf.mjs';
+import { d as durableIteratorContract } from '../shared/experimental-durable-iterator.BRB0hiXN.mjs';
+import { StandardRPCJsonSerializer } from '@orpc/client/standard';
+import { DurableObject } from 'cloudflare:workers';
+import '@orpc/server/helpers';
+import 'valibot';
+import '@orpc/contract';
+
+const websocketReferencesCache = /* @__PURE__ */ new WeakMap();
+function toDurableIteratorWebsocket(original) {
+  if ("~orpc" in original) {
+    return original;
+  }
+  const cached = websocketReferencesCache.get(original);
+  if (cached) {
+    return cached;
+  }
+  const internal = {
+    original,
+    serializeId(id) {
+      original.serializeAttachment({
+        ...original.deserializeAttachment(),
+        id
+      });
+    },
+    deserializeId() {
+      const id = original.deserializeAttachment()?.id;
+      if (!id) {
+        throw new DurableIteratorError("ID not found, please call serializeId first");
+      }
+      return id;
+    },
+    serializeTokenPayload(payload) {
+      original.serializeAttachment({
+        ...original.deserializeAttachment(),
+        tp: payload
+      });
+    },
+    deserializeTokenPayload() {
+      const payload = original.deserializeAttachment()?.tp;
+      if (!payload) {
+        throw new DurableIteratorError("Token payload not found, please call serializeTokenPayload first");
+      }
+      return payload;
+    },
+    serializeHibernationId(id) {
+      original.serializeAttachment({
+        ...original.deserializeAttachment(),
+        hi: id
+      });
+    },
+    deserializeHibernationId() {
+      return original.deserializeAttachment()?.hi;
+    },
+    closeIfExpired() {
+      const payload = internal.deserializeTokenPayload();
+      if (payload.exp < Date.now() / 1e3) {
+        original.close(1008, "Token expired");
+      }
+    }
+  };
+  const serializeAttachment = (wa) => {
+    original.serializeAttachment({
+      ...original.deserializeAttachment(),
+      wa
+    });
+  };
+  const deserializeAttachment = () => {
+    return original.deserializeAttachment()?.wa;
+  };
+  const send = (data) => {
+    internal.closeIfExpired();
+    return original.send(data);
+  };
+  const proxy = new Proxy(original, {
+    get(_, prop) {
+      if (prop === "~orpc") {
+        return internal;
+      }
+      if (prop === "serializeAttachment") {
+        return serializeAttachment;
+      }
+      if (prop === "deserializeAttachment") {
+        return deserializeAttachment;
+      }
+      if (prop === "send") {
+        return send;
+      }
+      const v = Reflect.get(original, prop);
+      return typeof v === "function" ? v.bind(original) : v;
+    },
+    has(_, p) {
+      return p === "~orpc" || Reflect.has(original, p);
+    }
+  });
+  websocketReferencesCache.set(original, proxy);
+  return proxy;
+}
+
+function toDurableIteratorObjectState(original) {
+  if ("~orpc" in original) {
+    return original;
+  }
+  const internal = {
+    original
+  };
+  const getWebSockets = (...args) => {
+    return original.getWebSockets(...args).map((ws) => toDurableIteratorWebsocket(ws));
+  };
+  const proxy = new Proxy(original, {
+    get(_, prop) {
+      if (prop === "~orpc") {
+        return internal;
+      }
+      if (prop === "getWebSockets") {
+        return getWebSockets;
+      }
+      const v = Reflect.get(original, prop);
+      return typeof v === "function" ? v.bind(original) : v;
+    },
+    has(_, p) {
+      return p === "~orpc" || Reflect.has(original, p);
+    }
+  });
+  return proxy;
+}
+
+class EventResumeStorage {
+  constructor(durableState, options = {}) {
+    this.durableState = durableState;
+    this.retentionSeconds = fallback(options.resumeRetentionSeconds, Number.NaN);
+    this.schemaPrefix = fallback(options.resumeSchemaPrefix, "orpc:durable-iterator:resume:");
+    this.serializer = new StandardRPCJsonSerializer(options);
+    if (this.isEnabled) {
+      this.initSchema();
+      this.cleanupExpiredEvents();
+    }
+  }
+  serializer;
+  retentionSeconds;
+  schemaPrefix;
+  get isEnabled() {
+    return Number.isFinite(this.retentionSeconds) && this.retentionSeconds > 0;
+  }
+  /**
+   * Store an payload for resume capability.
+   *
+   * @returns The updated meta of the stored payload
+   */
+  store(payload, resumeFilter) {
+    if (!this.isEnabled) {
+      return payload;
+    }
+    this.cleanupExpiredEvents();
+    const serializedEvent = this.serializeEventPayload(payload);
+    const targetIds = resumeFilter.targets?.map(
+      (ws) => ws["~orpc"].deserializeId()
+    );
+    const excludeIds = resumeFilter.exclude?.map(
+      (ws) => ws["~orpc"].deserializeId()
+    );
+    const insertEvent = () => {
+      const insertResult = this.durableState.storage.sql.exec(
+        `INSERT INTO "${this.schemaPrefix}events" (payload, tags, target_ids, exclusion_ids) VALUES (?, ?, ?, ?) RETURNING CAST(id AS TEXT) as id`,
+        serializedEvent,
+        stringifyJSON(resumeFilter.tags),
+        stringifyJSON(targetIds),
+        stringifyJSON(excludeIds)
+      );
+      const id = insertResult.one()?.id;
+      return this.withEventId(payload, id);
+    };
+    try {
+      return insertEvent();
+    } catch {
+      this.resetSchema();
+      return insertEvent();
+    }
+  }
+  /**
+   * Get events after lastEventId for a specific websocket
+   */
+  get(websocket, lastEventId) {
+    if (!this.isEnabled) {
+      return [];
+    }
+    this.cleanupExpiredEvents();
+    const websocketTags = websocket["~orpc"].deserializeTokenPayload().tags;
+    const websocketId = websocket["~orpc"].deserializeId();
+    const resumeQuery = this.durableState.storage.sql.exec(`
+      SELECT CAST(id AS TEXT) as id, payload, tags, target_ids, exclusion_ids
+      FROM "${this.schemaPrefix}events"
+      WHERE id > ?
+      ORDER BY id ASC
+    `, lastEventId);
+    return resumeQuery.toArray().filter((resumeRecord) => {
+      const tags = parseEmptyableJSON(resumeRecord.tags);
+      if (tags && !tags.some((tag) => websocketTags?.includes(tag))) {
+        return false;
+      }
+      const resumeTargetIds = parseEmptyableJSON(resumeRecord.target_ids);
+      const resumeExclusionIds = parseEmptyableJSON(resumeRecord.exclusion_ids);
+      if (resumeTargetIds && !resumeTargetIds.includes(websocketId)) {
+        return false;
+      }
+      if (resumeExclusionIds && resumeExclusionIds.includes(websocketId)) {
+        return false;
+      }
+      return true;
+    }).map((resumeRecord) => this.withEventId(
+      this.deserializeEventPayload(resumeRecord.payload),
+      resumeRecord.id
+    ));
+  }
+  initSchema() {
+    this.durableState.storage.sql.exec(`
+      CREATE TABLE IF NOT EXISTS "${this.schemaPrefix}events" (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        payload TEXT NOT NULL,
+        tags TEXT,
+        target_ids TEXT,
+        exclusion_ids TEXT,
+        stored_at INTEGER NOT NULL DEFAULT (unixepoch())
+      )
+    `);
+    this.durableState.storage.sql.exec(`
+      CREATE INDEX IF NOT EXISTS "${this.schemaPrefix}idx_events_id" ON "${this.schemaPrefix}events" (id)
+    `);
+    this.durableState.storage.sql.exec(`
+      CREATE INDEX IF NOT EXISTS "${this.schemaPrefix}idx_events_stored_at" ON "${this.schemaPrefix}events" (stored_at)
+    `);
+  }
+  resetSchema() {
+    this.durableState.storage.sql.exec(`
+      DROP TABLE IF EXISTS "${this.schemaPrefix}events"
+    `);
+    this.initSchema();
+  }
+  cleanupExpiredEvents() {
+    this.durableState.storage.sql.exec(`
+      DELETE FROM "${this.schemaPrefix}events" WHERE stored_at < unixepoch() - ?
+    `, this.retentionSeconds);
+  }
+  serializeEventPayload(payload) {
+    const eventMeta = getEventMeta(payload);
+    const [json, meta] = this.serializer.serialize({ payload, meta: eventMeta });
+    return stringifyJSON({ json, meta });
+  }
+  deserializeEventPayload(payload) {
+    const { json, meta } = JSON.parse(payload);
+    const { payload: deserializedPayload, meta: eventMeta } = this.serializer.deserialize(json, meta);
+    return eventMeta ? withEventMeta(deserializedPayload, eventMeta) : deserializedPayload;
+  }
+  withEventId(payload, id) {
+    return withEventMeta(payload, {
+      ...getEventMeta(payload),
+      id
+    });
+  }
+}
+
+const os = implement(durableIteratorContract);
+const base = os.$context();
+const router = base.router({
+  updateToken: base.updateToken.handler(async ({ context, input }) => {
+    const payload = await verifyDurableIteratorToken(context.options.signingKey, input.token);
+    if (!payload) {
+      throw new ORPCError("UNAUTHORIZED", { message: "Invalid Token" });
+    }
+    const old = context.websocket["~orpc"].deserializeTokenPayload();
+    if (payload.chn !== old.chn) {
+      throw new ORPCError("UNAUTHORIZED", { message: "Updated token must have the same channel with the original token" });
+    }
+    if (stringifyJSON(payload.tags) !== stringifyJSON(old.tags)) {
+      throw new ORPCError("UNAUTHORIZED", { message: "Updated token must have the exact same tags with the original token" });
+    }
+    context.websocket["~orpc"].serializeTokenPayload(payload);
+  }),
+  subscribe: base.subscribe.handler(({ context, lastEventId }) => {
+    return new HibernationEventIterator((hibernationId) => {
+      context.websocket["~orpc"].serializeHibernationId(hibernationId);
+      if (typeof lastEventId === "string") {
+        const resumePayloads = context.resumeStorage.get(context.websocket, lastEventId);
+        try {
+          for (const payload of resumePayloads) {
+            context.websocket.send(
+              encodeHibernationRPCEvent(hibernationId, payload, context.options)
+            );
+          }
+        } catch {
+        }
+      }
+      context.options.onSubscribed?.(context.websocket, lastEventId);
+    });
+  }),
+  call: base.call.handler(({ context, input, signal, lastEventId }) => {
+    const allowMethods = context.websocket["~orpc"].deserializeTokenPayload().rpc;
+    const [method, ...path] = input.path;
+    if (!allowMethods?.includes(method)) {
+      throw new ORPCError("FORBIDDEN", {
+        message: `Method "${method}" is not allowed.`
+      });
+    }
+    const nestedClient = context.object[method](context.websocket);
+    const client = get(nestedClient, path);
+    return client(input.input, { signal, lastEventId });
+  })
+});
+class DurableIteratorObjectHandler {
+  constructor(ctx, object, options) {
+    this.object = object;
+    this.options = options;
+    this.ctx = toDurableIteratorObjectState(ctx);
+    this.resumeStorage = new EventResumeStorage(ctx, options);
+    this.handler = new RPCHandler(router, {
+      ...options,
+      plugins: [
+        ...toArray(options.plugins),
+        new HibernationPlugin()
+      ]
+    });
+    this.ctx.getWebSockets().forEach((ws) => ws["~orpc"].closeIfExpired());
+  }
+  "~eventPayloadType";
+  // Helps DurableIteratorObjectDef infer the type
+  handler;
+  resumeStorage;
+  /**
+   * Proxied, ensure you don't accidentally change internal state, and auto close if expired websockets before .send is called
+   */
+  ctx;
+  /**
+   * Publish an event to a set of clients.
+   */
+  publishEvent(payload, options = {}) {
+    let targets = Array.isArray(options.targets) ? options.targets.map(toDurableIteratorWebsocket) : void 0;
+    const websocketsFilteredByTags = (() => {
+      if (targets) {
+        const uniqueTargets = targets.filter((ws, index) => {
+          const id = ws["~orpc"].deserializeId();
+          return targets?.findIndex((ws2) => ws2["~orpc"].deserializeId() === id) === index;
+        });
+        if (!options.tags) {
+          return uniqueTargets;
+        }
+        return uniqueTargets.filter(
+          (ws) => ws["~orpc"].deserializeTokenPayload().tags?.some((tag) => options.tags?.includes(tag))
+        );
+      }
+      if (options.tags) {
+        const websockets = options.tags.map((tag) => this.ctx.getWebSockets(tag)).flat();
+        const uniqueWebsockets = websockets.filter((ws, index) => {
+          const id = ws["~orpc"].deserializeId();
+          return websockets.findIndex((ws2) => ws2["~orpc"].deserializeId() === id) === index;
+        });
+        return uniqueWebsockets;
+      } else {
+        return this.ctx.getWebSockets();
+      }
+    })();
+    if (typeof options.targets === "function") {
+      targets = websocketsFilteredByTags.filter(options.targets);
+    }
+    const exclude = Array.isArray(options.exclude) ? options.exclude.map(toDurableIteratorWebsocket) : typeof options.exclude === "function" ? websocketsFilteredByTags.filter(options.exclude) : void 0;
+    payload = this.resumeStorage.store(payload, { tags: options.tags, targets, exclude });
+    const targetIds = targets?.map((ws) => ws["~orpc"].deserializeId());
+    const excludeIds = exclude?.map((ws) => ws["~orpc"].deserializeId());
+    for (const ws of websocketsFilteredByTags) {
+      const wsId = ws["~orpc"].deserializeId();
+      if (targetIds && !targetIds.includes(wsId)) {
+        continue;
+      }
+      if (excludeIds?.includes(wsId)) {
+        continue;
+      }
+      const hibernationId = ws["~orpc"].deserializeHibernationId();
+      if (typeof hibernationId !== "string") {
+        continue;
+      }
+      const data = encodeHibernationRPCEvent(hibernationId, payload, this.options);
+      try {
+        ws.send(data);
+      } catch {
+      }
+    }
+  }
+  /**
+   * This method is called when a HTTP request is received for upgrading to a WebSocket connection.
+   * Should mapping with corresponding `fetch` inside durable object
+   */
+  async fetch(request) {
+    const url = new URL(request.url);
+    const token = url.searchParams.getAll(DURABLE_ITERATOR_TOKEN_PARAM).at(-1);
+    const id = url.searchParams.getAll(DURABLE_ITERATOR_ID_PARAM).at(-1);
+    if (typeof id !== "string") {
+      return new Response("ID is required", { status: 401 });
+    }
+    if (typeof token !== "string") {
+      return new Response("Token is required", { status: 401 });
+    }
+    const payload = await verifyDurableIteratorToken(this.options.signingKey, token);
+    if (!payload) {
+      return new Response("Invalid Token", { status: 401 });
+    }
+    const { "0": client, "1": server } = new WebSocketPair();
+    if (payload.tags) {
+      this.ctx.acceptWebSocket(server, [...payload.tags]);
+    } else {
+      this.ctx.acceptWebSocket(server);
+    }
+    toDurableIteratorWebsocket(server)["~orpc"].serializeId(id);
+    toDurableIteratorWebsocket(server)["~orpc"].serializeTokenPayload(payload);
+    return new Response(null, {
+      status: 101,
+      webSocket: client
+    });
+  }
+  /**
+   * This method is called when a WebSocket message is received.
+   * Should mapping with corresponding `webSocketMessage` inside durable object
+   */
+  async webSocketMessage(websocket_, message) {
+    const websocket = toDurableIteratorWebsocket(websocket_);
+    websocket["~orpc"].closeIfExpired();
+    if (websocket.readyState !== WebSocket.OPEN) {
+      return;
+    }
+    await this.handler.message(websocket, message, {
+      context: {
+        websocket,
+        object: this.object,
+        resumeStorage: this.resumeStorage,
+        options: this.options
+      }
+    });
+  }
+  /**
+   * This method is called when a WebSocket connection is closed.
+   * Should mapping with corresponding `webSocketClose` inside durable object
+   */
+  webSocketClose(ws_, _code, _reason, _wasClean) {
+    const ws = toDurableIteratorWebsocket(ws_);
+    this.handler.close(ws);
+  }
+}
+
+class DurableIteratorObject extends DurableObject {
+  "~orpc";
+  /**
+   * Proxied, ensure you don't accidentally change internal state, and auto close if expired websockets before .send is called
+   */
+  ctx;
+  constructor(ctx, env, options) {
+    if (!options) {
+      throw new DurableIteratorError(`
+        Missing options (3rd argument) for DurableIteratorObject.
+        When extending DurableIteratorObject, you must define your own constructor
+        and call super(ctx, env, options).
+      `);
+    }
+    super(ctx, env);
+    this["~orpc"] = new DurableIteratorObjectHandler(ctx, this, options);
+    this.ctx = this["~orpc"].ctx;
+  }
+  /**
+   * Publish an event to clients
+   */
+  publishEvent(payload, options = {}) {
+    return this["~orpc"].publishEvent(payload, options);
+  }
+  /**
+   * Upgrades websocket connection
+   *
+   * @info You can safety intercept non-upgrade requests
+   * @warning No verification is done here, you should verify the token payload before calling this method.
+   */
+  fetch(request) {
+    return this["~orpc"].fetch(request);
+  }
+  /**
+   * Handle WebSocket messages
+   *
+   * @warning Use `toDurableIteratorWebsocket` to proxy the WebSocket when interacting
+   *          to avoid accidentally modifying internal state, and auto close if expired before .send is called
+   */
+  webSocketMessage(websocket, message) {
+    return this["~orpc"].webSocketMessage(websocket, message);
+  }
+  /**
+   * Handle WebSocket close event
+   *
+   * @warning Use `toDurableIteratorWebsocket` to proxy the WebSocket when interacting
+   *          to avoid accidentally modifying internal state, and auto close if expired before .send is called
+   */
+  webSocketClose(websocket, code, reason, wasClean) {
+    return this["~orpc"].webSocketClose(websocket, code, reason, wasClean);
+  }
+}
+
+async function upgradeDurableIteratorRequest(request, options) {
+  if (request.headers.get("upgrade") !== "websocket") {
+    return new Response("Expected WebSocket upgrade", {
+      status: 426
+    });
+  }
+  const url = new URL(request.url);
+  const token = url.searchParams.getAll(DURABLE_ITERATOR_TOKEN_PARAM).at(-1);
+  const id = url.searchParams.getAll(DURABLE_ITERATOR_ID_PARAM).at(-1);
+  if (typeof id !== "string") {
+    return new Response("ID is required", { status: 401 });
+  }
+  if (!token) {
+    return new Response("Token is required", { status: 401 });
+  }
+  const payload = await verifyDurableIteratorToken(options.signingKey, token);
+  if (!payload) {
+    return new Response("Invalid Token", { status: 401 });
+  }
+  return intercept(
+    toArray(options.interceptors),
+    { payload },
+    async ({ payload: payload2 }) => {
+      const namespace = options.namespace;
+      const id2 = namespace.idFromName(payload2.chn);
+      const stub = namespace.get(id2, options.namespaceGetOptions);
+      return stub.fetch(request);
+    }
+  );
+}
+
+export { DurableIteratorObject, DurableIteratorObjectHandler, EventResumeStorage, toDurableIteratorObjectState, toDurableIteratorWebsocket, upgradeDurableIteratorRequest };

package/dist/index.d.mts

@@ -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.DrenXxND.mjs';
+import { D as DurableIteratorObject, I as InferDurableIteratorObjectRPC } from './shared/experimental-durable-iterator.DQjHfIr1.mjs';
+export { a as DurableIteratorObjectDef, b as DurableIteratorTokenPayload, p as parseDurableIteratorToken, s as signDurableIteratorToken, v as verifyDurableIteratorToken } from './shared/experimental-durable-iterator.DQjHfIr1.mjs';
+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 };