@blindmarket/sdk 0.1.8 → 0.4.0

package/src/crypto/hkdf.ts

@@ -1,45 +0,0 @@
-import { CryptoError } from '../errors/index.js';
-import { ECIES_HKDF_INFO } from './constants.js';
-
-function getSubtle(): SubtleCrypto {
-  const c = (globalThis as { crypto?: Crypto }).crypto;
-  if (!c?.subtle) {
-    throw new CryptoError('CRYPTO/UNSUPPORTED_CIPHER', 'Web Crypto (crypto.subtle) is not available');
-  }
-  return c.subtle;
-}
-
-function toArrayBuffer(u: Uint8Array): ArrayBuffer {
-  const ab = new ArrayBuffer(u.byteLength);
-  new Uint8Array(ab).set(u);
-  return ab;
-}
-
-/**
- * HKDF-SHA256. Defaults match backend: empty salt, the ECIES domain separation info,
- * 32-byte output length. Pass custom values for other uses.
- */
-export async function hkdfSha256(
-  ikm: Uint8Array,
-  length = 32,
-  info: Uint8Array = ECIES_HKDF_INFO,
-  salt: Uint8Array = new Uint8Array(0),
-): Promise<Uint8Array> {
-  try {
-    const subtle = getSubtle();
-    const baseKey = await subtle.importKey('raw', toArrayBuffer(ikm), 'HKDF', false, ['deriveBits']);
-    const derived = await subtle.deriveBits(
-      {
-        name: 'HKDF',
-        hash: 'SHA-256',
-        info: toArrayBuffer(info),
-        salt: toArrayBuffer(salt),
-      },
-      baseKey,
-      length * 8,
-    );
-    return new Uint8Array(derived);
-  } catch (cause) {
-    throw new CryptoError('CRYPTO/INVALID_KEY', 'HKDF derivation failed', { cause });
-  }
-}

package/src/crypto/index.ts

@@ -1,6 +0,0 @@
-export * from './constants.js';
-export * from './aes.js';
-export * from './ecies.js';
-export * from './keys.js';
-export * from './envelope.js';
-export { hkdfSha256 } from './hkdf.js';

package/src/crypto/keys.ts

@@ -1,56 +0,0 @@
-import { ethers } from 'ethers';
-import { CryptoError } from '../errors/index.js';
-
-export interface KeyPair {
-  privateKey: string;
-  publicKey: string;
-}
-
-/** Fresh secp256k1 keypair. Hex strings returned un-prefixed (no 0x). */
-export function generateKeyPair(): KeyPair {
-  const w = ethers.Wallet.createRandom();
-  return {
-    privateKey: w.privateKey.slice(2),
-    publicKey: w.signingKey.publicKey.slice(2),
-  };
-}
-
-/** Recover the uncompressed public key (un-prefixed hex) from a private key. */
-export function derivePublicKey(privateKey: string): string {
-  const sk = new ethers.SigningKey(`0x${strip(privateKey)}`);
-  return sk.publicKey.slice(2);
-}
-
-export function strip(hex: string): string {
-  return hex.startsWith('0x') || hex.startsWith('0X') ? hex.slice(2) : hex;
-}
-
-export function assertUncompressedPubKey(pub: string): void {
-  const s = strip(pub);
-  if (s.length !== 130 || !/^04/i.test(s)) {
-    throw new CryptoError(
-      'CRYPTO/INVALID_KEY',
-      'expected uncompressed secp256k1 pubkey (65 bytes hex, starts with 04)',
-    );
-  }
-}
-
-export function hexToBytes(hex: string): Uint8Array {
-  const s = strip(hex);
-  if (s.length % 2 !== 0) {
-    throw new CryptoError('CRYPTO/INVALID_KEY', 'hex string has odd length');
-  }
-  const out = new Uint8Array(s.length / 2);
-  for (let i = 0; i < out.length; i++) {
-    const byte = Number.parseInt(s.substring(i * 2, i * 2 + 2), 16);
-    if (Number.isNaN(byte)) {
-      throw new CryptoError('CRYPTO/INVALID_KEY', `invalid hex byte at position ${i * 2}`);
-    }
-    out[i] = byte;
-  }
-  return out;
-}
-
-export function bytesToHex(u: Uint8Array): string {
-  return Array.from(u, (b) => b.toString(16).padStart(2, '0')).join('');
-}

package/src/errors/BlindMarketError.ts

@@ -1,38 +0,0 @@
-import type { ErrorCode } from './codes.js';
-
-export interface ErrorOptions {
-  retriable?: boolean;
-  context?: Record<string, unknown>;
-  cause?: unknown;
-}
-
-export abstract class BlindMarketError extends Error {
-  readonly code: ErrorCode;
-  readonly retriable: boolean;
-  readonly context?: Record<string, unknown>;
-  override readonly cause?: unknown;
-
-  constructor(code: ErrorCode, message: string, opts: ErrorOptions = {}) {
-    super(message);
-    this.code = code;
-    this.retriable = opts.retriable ?? false;
-    if (opts.context !== undefined) this.context = opts.context;
-    if (opts.cause !== undefined) this.cause = opts.cause;
-    Object.defineProperty(this, 'name', {
-      value: this.constructor.name,
-      enumerable: false,
-      configurable: true,
-      writable: true,
-    });
-  }
-
-  toJSON(): Record<string, unknown> {
-    return {
-      name: this.name,
-      code: this.code,
-      message: this.message,
-      retriable: this.retriable,
-      ...(this.context ? { context: this.context } : {}),
-    };
-  }
-}

package/src/errors/codes.ts

@@ -1,67 +0,0 @@
-export const ErrorCodes = {
-  Config: ['CONFIG/INVALID_NETWORK', 'CONFIG/MISSING_SIGNER', 'CONFIG/BAD_CONFIG'] as const,
-  Crypto: [
-    'CRYPTO/INVALID_KEY',
-    'CRYPTO/DECRYPT_FAILED',
-    'CRYPTO/INTEGRITY_CHECK',
-    'CRYPTO/UNSUPPORTED_CIPHER',
-  ] as const,
-  Storage: [
-    'STORAGE/UPLOAD_FAILED',
-    'STORAGE/DOWNLOAD_FAILED',
-    'STORAGE/MERKLE_MISMATCH',
-    'STORAGE/NOT_FOUND',
-    'STORAGE/INDEXER_UNREACHABLE',
-  ] as const,
-  Chain: [
-    'CHAIN/TX_REVERTED',
-    'CHAIN/TX_TIMED_OUT',
-    'CHAIN/NONCE_CONFLICT',
-    'CHAIN/INSUFFICIENT_BALANCE',
-    'CHAIN/NETWORK_MISMATCH',
-    'CHAIN/CONTRACT_NOT_DEPLOYED',
-  ] as const,
-  Compute: [
-    'COMPUTE/BROKER_UNREACHABLE',
-    'COMPUTE/NO_PROVIDERS',
-    'COMPUTE/LEDGER_INSUFFICIENT',
-    'COMPUTE/TEE_ATTESTATION_INVALID',
-    'COMPUTE/VERIFICATION_TIMEOUT',
-  ] as const,
-  Api: [
-    'API/AUTH_REQUIRED',
-    'API/AUTH_EXPIRED',
-    'API/FORBIDDEN',
-    'API/RATE_LIMITED',
-    'API/VALIDATION',
-    'API/SERVER',
-    'API/NOT_FOUND',
-  ] as const,
-  Lifecycle: [
-    'LIFECYCLE/ILLEGAL_TRANSITION',
-    'LIFECYCLE/TASK_NOT_FOUND',
-    'LIFECYCLE/NOT_ASSIGNED',
-    'LIFECYCLE/ALREADY_SUBMITTED',
-    'LIFECYCLE/CLAIM_NOT_READY',
-  ] as const,
-  Timeout: ['TIMEOUT'] as const,
-} as const;
-
-export type ConfigCode = (typeof ErrorCodes.Config)[number];
-export type CryptoCode = (typeof ErrorCodes.Crypto)[number];
-export type StorageCode = (typeof ErrorCodes.Storage)[number];
-export type ChainCode = (typeof ErrorCodes.Chain)[number];
-export type ComputeCode = (typeof ErrorCodes.Compute)[number];
-export type ApiCode = (typeof ErrorCodes.Api)[number];
-export type LifecycleCode = (typeof ErrorCodes.Lifecycle)[number];
-export type TimeoutCode = (typeof ErrorCodes.Timeout)[number];
-
-export type ErrorCode =
-  | ConfigCode
-  | CryptoCode
-  | StorageCode
-  | ChainCode
-  | ComputeCode
-  | ApiCode
-  | LifecycleCode
-  | TimeoutCode;

package/src/errors/index.ts

@@ -1,3 +0,0 @@
-export * from './codes.js';
-export * from './BlindMarketError.js';
-export * from './subclasses.js';

package/src/errors/subclasses.ts

@@ -1,59 +0,0 @@
-import { BlindMarketError, type ErrorOptions } from './BlindMarketError.js';
-import type {
-  ApiCode,
-  ChainCode,
-  ComputeCode,
-  ConfigCode,
-  CryptoCode,
-  LifecycleCode,
-  StorageCode,
-  TimeoutCode,
-} from './codes.js';
-
-export class ConfigError extends BlindMarketError {
-  constructor(code: ConfigCode, msg: string, opts?: ErrorOptions) {
-    super(code, msg, opts);
-  }
-}
-
-export class CryptoError extends BlindMarketError {
-  constructor(code: CryptoCode, msg: string, opts?: ErrorOptions) {
-    super(code, msg, opts);
-  }
-}
-
-export class StorageError extends BlindMarketError {
-  constructor(code: StorageCode, msg: string, opts?: ErrorOptions) {
-    super(code, msg, opts);
-  }
-}
-
-export class ChainError extends BlindMarketError {
-  constructor(code: ChainCode, msg: string, opts?: ErrorOptions) {
-    super(code, msg, opts);
-  }
-}
-
-export class ComputeError extends BlindMarketError {
-  constructor(code: ComputeCode, msg: string, opts?: ErrorOptions) {
-    super(code, msg, opts);
-  }
-}
-
-export class ApiError extends BlindMarketError {
-  constructor(code: ApiCode, msg: string, opts?: ErrorOptions) {
-    super(code, msg, opts);
-  }
-}
-
-export class LifecycleError extends BlindMarketError {
-  constructor(code: LifecycleCode, msg: string, opts?: ErrorOptions) {
-    super(code, msg, opts);
-  }
-}
-
-export class TimeoutError extends BlindMarketError {
-  constructor(code: TimeoutCode, msg: string, opts?: ErrorOptions) {
-    super(code, msg, opts);
-  }
-}

package/src/events/EventBus.ts

@@ -1,45 +0,0 @@
-type Handler<T> = (payload: T) => void;
-
-/**
- * Typed pub/sub. Listener exceptions are swallowed so one bad subscriber
- * cannot block others — telemetry plugins can observe failures via onError.
- */
-export class EventBus<E> {
-  private handlers: { [K in keyof E]?: Set<Handler<E[K]>> } = {};
-
-  on<K extends keyof E>(event: K, fn: Handler<E[K]>): () => void {
-    let set = this.handlers[event];
-    if (!set) {
-      set = new Set<Handler<E[K]>>();
-      this.handlers[event] = set;
-    }
-    set.add(fn);
-    return () => {
-      this.off(event, fn);
-    };
-  }
-
-  once<K extends keyof E>(event: K, fn: Handler<E[K]>): () => void {
-    const wrapped: Handler<E[K]> = (p) => {
-      this.off(event, wrapped);
-      fn(p);
-    };
-    return this.on(event, wrapped);
-  }
-
-  off<K extends keyof E>(event: K, fn: Handler<E[K]>): void {
-    this.handlers[event]?.delete(fn);
-  }
-
-  emit<K extends keyof E>(event: K, payload: E[K]): void {
-    const hs = this.handlers[event];
-    if (!hs) return;
-    for (const h of hs) {
-      try {
-        h(payload);
-      } catch {
-        // Isolated per-listener — prevents one bad subscriber from blocking others.
-      }
-    }
-  }
-}

package/src/events/index.ts

@@ -1,2 +0,0 @@
-export * from './EventBus.js';
-export * from './types.js';

package/src/events/types.ts

@@ -1,13 +0,0 @@
-import type { Address, Hex, RootHash, TaskId } from '../types.js';
-
-export interface SdkEvents {
-  'task.created': { taskId: TaskId; txHash: Hex; rootHash: RootHash };
-  'task.assigned': { taskId: TaskId; worker: Address; txHash: Hex };
-  'task.cancelled': { taskId: TaskId; txHash: Hex };
-  'evidence.submitted': { taskId: TaskId; rootHash: RootHash; txHash: Hex };
-  'verification.done': { taskId: TaskId; passed: boolean; confidence: number };
-  'payment.claimed': { taskId: TaskId; txHash: Hex; amount: bigint };
-  'tx.sent': { hash: Hex; from: Address; to: Address };
-  'tx.confirmed': { hash: Hex; blockNumber: number };
-  'tx.failed': { hash: Hex; reason: string };
-}

package/src/executor/WorkerRuntime.ts

@@ -1,338 +0,0 @@
-import { BlindMarket } from '../index.js';
-import { eciesDecrypt, aesDecrypt } from '../crypto/index.js';
-import type {
-  A2ATaskState, AgentCapability, ExecutorProfile, Message,
-} from '../types.js';
-
-// ── Config ──────────────────────────────────────────────────────────────────
-
-export interface WorkerRuntimeConfig {
-  apiKey: string;
-  apiBase?: string;
-  displayName: string;
-  capabilities: AgentCapability[];
-  executeTask: ExecuteTaskHandler;
-  existingPrivateKey?: string;
-  existingAddress?: string;
-  existingPublicKey?: string;
-  minReward?: string;
-  preferredCapabilities?: AgentCapability[];
-  browseIntervalMs?: number;
-  watchIntervalMs?: number;
-  maxConcurrentTasks?: number;
-}
-
-// ── Types ───────────────────────────────────────────────────────────────────
-
-export type ExecuteTaskHandler = (ctx: TaskContext) => Promise<Record<string, unknown>>;
-
-export interface TaskContext {
-  taskId: string;
-  task: A2ATaskState;
-  instructions: string;
-}
-
-export interface TaskExecutionInfo {
-  taskId: string;
-  status: 'bidding' | 'assigned' | 'working' | 'submitted' | 'completed' | 'failed';
-  task?: A2ATaskState;
-  error?: string;
-  startedAt: number;
-}
-
-export type WorkerRuntimeEvent =
-  | { type: 'started' }
-  | { type: 'stopped' }
-  | { type: 'paused' }
-  | { type: 'resumed' }
-  | { type: 'registered'; profile: ExecutorProfile }
-  | { type: 'task_found'; taskId: string; task: A2ATaskState }
-  | { type: 'task_bidded'; taskId: string }
-  | { type: 'task_assigned'; taskId: string }
-  | { type: 'task_accepted'; taskId: string }
-  | { type: 'task_working'; taskId: string }
-  | { type: 'task_executed'; taskId: string }
-  | { type: 'task_submitted'; taskId: string; result: Record<string, unknown> }
-  | { type: 'task_failed'; taskId: string; error: string }
-  | { type: 'message_received'; message: Message; count: number }
-  | { type: 'browse_done'; found: number }
-  | { type: 'error'; error: string };
-
-// ── Defaults ────────────────────────────────────────────────────────────────
-
-const DEFAULTS = {
-  browseIntervalMs: 15_000,
-  watchIntervalMs: 5_000,
-  maxConcurrentTasks: 3,
-};
-
-// ── WorkerRuntime ───────────────────────────────────────────────────────────
-
-export class WorkerRuntime {
-  private bb: BlindMarket;
-  private config: WorkerRuntimeConfig & typeof DEFAULTS;
-  private wallet?: { address: string; privateKey: string; publicKey: string };
-  private profile?: ExecutorProfile;
-  private running = false;
-  private paused = false;
-  private browseTimer?: ReturnType<typeof setInterval>;
-  private watchTimers = new Map<string, ReturnType<typeof setInterval>>();
-  private executions = new Map<string, TaskExecutionInfo>();
-  private listeners = new Set<(event: WorkerRuntimeEvent) => void>();
-
-  constructor(config: WorkerRuntimeConfig) {
-    this.config = { ...DEFAULTS, ...config };
-    this.bb = new BlindMarket({ apiKey: config.apiKey, apiBase: config.apiBase });
-  }
-
-  // ── Status ──────────────────────────────────────────────────────────────
-
-  get isRunning(): boolean {
-    return this.running;
-  }
-
-  get isPaused(): boolean {
-    return this.paused;
-  }
-
-  get activeExecutions(): TaskExecutionInfo[] {
-    return [...this.executions.values()];
-  }
-
-  /** Get own executor profile (available after start). */
-  get executorProfile(): ExecutorProfile | undefined {
-    return this.profile;
-  }
-
-  /** Get own wallet info (available after start). */
-  get executorWallet(): { address: string; publicKey: string } | undefined {
-    return this.wallet;
-  }
-
-  // ── Events ──────────────────────────────────────────────────────────────
-
-  on(listener: (event: WorkerRuntimeEvent) => void): () => void {
-    this.listeners.add(listener);
-    return () => this.listeners.delete(listener);
-  }
-
-  private emit(event: WorkerRuntimeEvent): void {
-    for (const l of this.listeners) l(event);
-  }
-
-  // ── Lifecycle ───────────────────────────────────────────────────────────
-
-  async start(): Promise<ExecutorProfile> {
-    if (this.running) return this.profile!;
-
-    // 1. Register or restore executor
-    if (this.config.existingPrivateKey && this.config.existingAddress && this.config.existingPublicKey) {
-      this.wallet = {
-        address: this.config.existingAddress,
-        privateKey: this.config.existingPrivateKey,
-        publicKey: this.config.existingPublicKey,
-      };
-      // Fetch existing profile — backend identifies by API key
-      const result = await this.bb.getExecutorProfile();
-      this.profile = result.agent;
-    } else {
-      const result = await this.bb.createAgent({
-        displayName: this.config.displayName,
-        capabilities: this.config.capabilities,
-        minReward: this.config.minReward,
-        preferredCapabilities: this.config.preferredCapabilities,
-      });
-      this.wallet = {
-        address: result.wallet.address,
-        privateKey: result.wallet.privateKey,
-        publicKey: result.wallet.publicKey,
-      };
-      this.profile = result.executor;
-    }
-
-    this.emit({ type: 'registered', profile: this.profile });
-
-    // 2. Start the browse loop
-    this.running = true;
-    this.startBrowseLoop();
-    this.emit({ type: 'started' });
-
-    return this.profile;
-  }
-
-  stop(): void {
-    this.running = false;
-    if (this.browseTimer) {
-      clearInterval(this.browseTimer);
-      this.browseTimer = undefined;
-    }
-    for (const t of this.watchTimers.values()) clearInterval(t);
-    this.watchTimers.clear();
-    this.emit({ type: 'stopped' });
-  }
-
-  pause(): void {
-    if (!this.running || this.paused) return;
-    this.paused = true;
-    this.emit({ type: 'paused' });
-  }
-
-  resume(): void {
-    if (!this.running || !this.paused) return;
-    this.paused = false;
-    this.emit({ type: 'resumed' });
-    // Immediately browse instead of waiting for next interval
-    this.browse();
-  }
-
-  // ── Browse loop ─────────────────────────────────────────────────────────
-
-  private startBrowseLoop(): void {
-    const ms = this.config.browseIntervalMs;
-    this.browseTimer = setInterval(() => this.browse(), ms);
-    this.browse();
-  }
-
-  private async browse(): Promise<void> {
-    if (this.paused) return;
-    try {
-      const active = this.activeExecutions;
-      const inFlight = active.filter(e => e.status === 'bidding' || e.status === 'working').length;
-      if (inFlight >= this.config.maxConcurrentTasks) return;
-
-      const result = await this.bb.browseA2ATasks({
-        capabilities: this.config.capabilities,
-      });
-
-      this.emit({ type: 'browse_done', found: result.tasks.length });
-
-      for (const task of result.tasks) {
-        if (this.executions.has(task.taskId)) continue;
-        if (task.status !== 'open' && task.status !== 'bidding') continue;
-        if (task.executorAddress && task.executorAddress !== this.wallet?.address) continue;
-
-        this.executions.set(task.taskId, {
-          taskId: task.taskId,
-          status: 'bidding',
-          task,
-          startedAt: Date.now(),
-        });
-
-        this.emit({ type: 'task_found', taskId: task.taskId, task });
-
-        await this.bb.bidOnTask(task.taskId);
-        this.emit({ type: 'task_bidded', taskId: task.taskId });
-
-        this.watchForAssignment(task.taskId);
-      }
-    } catch (err) {
-      this.emit({ type: 'error', error: `Browse failed: ${err}` });
-    }
-  }
-
-  // ── Assignment watching ─────────────────────────────────────────────────
-
-  private watchForAssignment(taskId: string): void {
-    if (!this.running) return;
-    const ms = this.config.watchIntervalMs;
-    const timer = setInterval(async () => {
-      if (!this.running || this.paused) return;
-      try {
-        const detail = await this.bb.getTask(taskId);
-        const a2a = detail.a2aState;
-        if (!a2a) return;
-
-        if (a2a.status === 'assigned') {
-          clearInterval(timer);
-          this.watchTimers.delete(taskId);
-          this.emit({ type: 'task_assigned', taskId });
-          await this.executeTask(taskId, a2a);
-        }
-      } catch {
-        // Retry next tick
-      }
-    }, ms);
-    this.watchTimers.set(taskId, timer);
-  }
-
-  // ── Task execution ──────────────────────────────────────────────────────
-
-  private async executeTask(taskId: string, a2a: A2ATaskState): Promise<void> {
-    const exec = this.executions.get(taskId);
-    if (!exec) return;
-
-    try {
-      exec.status = 'assigned';
-
-      // Accept task — get the ECIES-wrapped AES key
-      const acceptResult = await this.bb.acceptTask(taskId);
-      exec.task = acceptResult.task;
-      this.emit({ type: 'task_accepted', taskId });
-
-      // Get full task detail for the storage root hash
-      const detail = await this.bb.getTask(taskId);
-      const taskHash = detail.taskHash;
-
-      // Decrypt the wrapped key with the worker's private key
-      let instructions = '';
-      if (acceptResult.wrappedKey && taskHash) {
-        const wrappedBytes = this.decodeWrappedKey(acceptResult.wrappedKey);
-        const aesKey = await eciesDecrypt(wrappedBytes, this.wallet!.privateKey);
-
-        // Download ciphertext from storage via REST API
-        const storageResult = await this.bb.downloadBlob(taskHash);
-        const ciphertext = this.hexToBytes(storageResult.data);
-
-        // AES decrypt to get plaintext instructions
-        const plaintext = await aesDecrypt(ciphertext, aesKey);
-        instructions = new TextDecoder().decode(plaintext);
-      }
-
-      exec.status = 'working';
-      this.emit({ type: 'task_working', taskId });
-
-      // Call the user-provided execution handler with decrypted instructions
-      const result = await this.config.executeTask({
-        taskId,
-        task: acceptResult.task,
-        instructions,
-      });
-
-      exec.status = 'submitted';
-      this.emit({ type: 'task_executed', taskId });
-
-      // Submit result
-      const submitResult = await this.bb.submitResult(taskId, result);
-
-      exec.status = 'completed';
-      this.emit({ type: 'task_submitted', taskId, result: submitResult });
-    } catch (err) {
-      exec.status = 'failed';
-      exec.error = String(err);
-      this.emit({ type: 'task_failed', taskId, error: String(err) });
-    }
-  }
-
-  // ── Helpers ─────────────────────────────────────────────────────────────
-
-  private decodeWrappedKey(wrappedKey: Record<string, string>): Uint8Array {
-    // Backend returns wrapped key as hex or base64 in a record
-    const hex = Object.values(wrappedKey)[0];
-    if (!hex) throw new Error('Empty wrapped key');
-    const clean = hex.startsWith('0x') ? hex.slice(2) : hex;
-    const bytes = new Uint8Array(clean.length / 2);
-    for (let i = 0; i < bytes.length; i++) {
-      bytes[i] = parseInt(clean.substring(i * 2, i * 2 + 2), 16);
-    }
-    return bytes;
-  }
-
-  private hexToBytes(hex: string): Uint8Array {
-    const clean = hex.startsWith('0x') ? hex.slice(2) : hex;
-    const bytes = new Uint8Array(clean.length / 2);
-    for (let i = 0; i < bytes.length; i++) {
-      bytes[i] = parseInt(clean.substring(i * 2, i * 2 + 2), 16);
-    }
-    return bytes;
-  }
-}

package/src/executor/index.ts

@@ -1,8 +0,0 @@
-export {
-  WorkerRuntime,
-  type WorkerRuntimeConfig,
-  type ExecuteTaskHandler,
-  type TaskContext,
-  type TaskExecutionInfo,
-  type WorkerRuntimeEvent,
-} from './WorkerRuntime.js';