@labacacia/nps-sdk 1.0.0-alpha.1

package/dist/nop/index.cjs

@@ -0,0 +1,762 @@
+'use strict';
+
+var msgpack = require('@msgpack/msgpack');
+
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var msgpack__namespace = /*#__PURE__*/_interopNamespace(msgpack);
+
+// src/nop/models.ts
+var TaskState = /* @__PURE__ */ ((TaskState2) => {
+  TaskState2["PENDING"] = "pending";
+  TaskState2["PREFLIGHT"] = "preflight";
+  TaskState2["RUNNING"] = "running";
+  TaskState2["WAITING_SYNC"] = "waiting_sync";
+  TaskState2["COMPLETED"] = "completed";
+  TaskState2["FAILED"] = "failed";
+  TaskState2["CANCELLED"] = "cancelled";
+  TaskState2["SKIPPED"] = "skipped";
+  return TaskState2;
+})(TaskState || {});
+var TaskPriority = /* @__PURE__ */ ((TaskPriority2) => {
+  TaskPriority2["LOW"] = "low";
+  TaskPriority2["NORMAL"] = "normal";
+  TaskPriority2["HIGH"] = "high";
+  return TaskPriority2;
+})(TaskPriority || {});
+var BackoffStrategy = /* @__PURE__ */ ((BackoffStrategy2) => {
+  BackoffStrategy2["FIXED"] = "fixed";
+  BackoffStrategy2["LINEAR"] = "linear";
+  BackoffStrategy2["EXPONENTIAL"] = "exponential";
+  return BackoffStrategy2;
+})(BackoffStrategy || {});
+var AggregateStrategy = /* @__PURE__ */ ((AggregateStrategy2) => {
+  AggregateStrategy2["MERGE"] = "merge";
+  AggregateStrategy2["FIRST"] = "first";
+  AggregateStrategy2["FASTEST_K"] = "fastest_k";
+  AggregateStrategy2["ALL"] = "all";
+  return AggregateStrategy2;
+})(AggregateStrategy || {});
+function computeDelayMs(policy, attempt) {
+  const base = policy.baseDelayMs ?? 1e3;
+  const cap = policy.maxDelayMs ?? 3e4;
+  let delay;
+  switch (policy.backoff) {
+    case "fixed" /* FIXED */:
+      delay = base;
+      break;
+    case "linear" /* LINEAR */:
+      delay = base * (attempt + 1);
+      break;
+    case "exponential" /* EXPONENTIAL */:
+      delay = base * Math.pow(2, attempt);
+      break;
+  }
+  return Math.min(delay, cap);
+}
+
+// src/core/exceptions.ts
+var NpsError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = new.target.name;
+  }
+};
+var NpsFrameError = class extends NpsError {
+};
+var NpsCodecError = class extends NpsError {
+};
+
+// src/core/frames.ts
+var FrameFlags = {
+  TIER1_JSON: 0,
+  TIER2_MSGPACK: 1,
+  FINAL: 4,
+  EXT: 128
+};
+var DEFAULT_HEADER_SIZE = 4;
+var EXTENDED_HEADER_SIZE = 8;
+var DEFAULT_MAX_PAYLOAD = 65535;
+var FrameHeader = class _FrameHeader {
+  constructor(frameType, flags, payloadLength) {
+    this.frameType = frameType;
+    this.flags = flags;
+    this.payloadLength = payloadLength;
+  }
+  frameType;
+  flags;
+  payloadLength;
+  get isExtended() {
+    return (this.flags & FrameFlags.EXT) !== 0;
+  }
+  get headerSize() {
+    return this.isExtended ? EXTENDED_HEADER_SIZE : DEFAULT_HEADER_SIZE;
+  }
+  get encodingTier() {
+    return this.flags & 3;
+  }
+  get isFinal() {
+    return (this.flags & 4) !== 0;
+  }
+  get isEncrypted() {
+    return (this.flags & 8) !== 0;
+  }
+  // ── Parsing ───────────────────────────────────────────────────────────────
+  static parse(buf) {
+    if (buf.length < 2) {
+      throw new NpsFrameError(
+        `Buffer too small to read frame type and flags: need >= 2 bytes, got ${buf.length}.`
+      );
+    }
+    const flags = buf[1];
+    const ext = (flags & FrameFlags.EXT) !== 0;
+    if (ext) {
+      if (buf.length < EXTENDED_HEADER_SIZE) {
+        throw new NpsFrameError(
+          `Buffer too small for extended frame header: need ${EXTENDED_HEADER_SIZE} bytes, got ${buf.length}.`
+        );
+      }
+      const view2 = new DataView(buf.buffer, buf.byteOffset);
+      const payloadLength2 = view2.getUint32(4, false);
+      return new _FrameHeader(buf[0], flags, payloadLength2);
+    }
+    if (buf.length < DEFAULT_HEADER_SIZE) {
+      throw new NpsFrameError(
+        `Buffer too small for frame header: need ${DEFAULT_HEADER_SIZE} bytes, got ${buf.length}.`
+      );
+    }
+    const view = new DataView(buf.buffer, buf.byteOffset);
+    const payloadLength = view.getUint16(2, false);
+    return new _FrameHeader(buf[0], flags, payloadLength);
+  }
+  // ── Serialisation ─────────────────────────────────────────────────────────
+  toBytes() {
+    if (this.isExtended) {
+      const buf2 = new Uint8Array(EXTENDED_HEADER_SIZE);
+      const view2 = new DataView(buf2.buffer);
+      view2.setUint8(0, this.frameType);
+      view2.setUint8(1, this.flags);
+      view2.setUint16(2, 0, false);
+      view2.setUint32(4, this.payloadLength, false);
+      return buf2;
+    }
+    const buf = new Uint8Array(DEFAULT_HEADER_SIZE);
+    const view = new DataView(buf.buffer);
+    view.setUint8(0, this.frameType);
+    view.setUint8(1, this.flags);
+    view.setUint16(2, this.payloadLength, false);
+    return buf;
+  }
+  toString() {
+    return `FrameHeader(frameType=0x${this.frameType.toString(16).padStart(2, "0")}, flags=0x${this.flags.toString(16).padStart(2, "0")}, payloadLength=${this.payloadLength})`;
+  }
+};
+
+// src/nop/frames.ts
+var TaskFrame = class _TaskFrame {
+  constructor(taskId, dag, timeoutMs, callbackUrl, context, priority, depth) {
+    this.taskId = taskId;
+    this.dag = dag;
+    this.timeoutMs = timeoutMs;
+    this.callbackUrl = callbackUrl;
+    this.context = context;
+    this.priority = priority;
+    this.depth = depth;
+  }
+  taskId;
+  dag;
+  timeoutMs;
+  callbackUrl;
+  context;
+  priority;
+  depth;
+  frameType = 64 /* TASK */;
+  preferredTier = 1 /* MSGPACK */;
+  toDict() {
+    return {
+      task_id: this.taskId,
+      dag: this.dag,
+      timeout_ms: this.timeoutMs ?? null,
+      callback_url: this.callbackUrl ?? null,
+      context: this.context ?? null,
+      priority: this.priority ?? null,
+      depth: this.depth ?? null
+    };
+  }
+  static fromDict(data) {
+    return new _TaskFrame(
+      data["task_id"],
+      data["dag"],
+      data["timeout_ms"] ?? void 0,
+      data["callback_url"] ?? void 0,
+      data["context"] ?? void 0,
+      data["priority"] ?? void 0,
+      data["depth"] ?? void 0
+    );
+  }
+};
+var DelegateFrame = class _DelegateFrame {
+  constructor(taskId, subtaskId, action, agentNid, inputs, params, idempotencyKey) {
+    this.taskId = taskId;
+    this.subtaskId = subtaskId;
+    this.action = action;
+    this.agentNid = agentNid;
+    this.inputs = inputs;
+    this.params = params;
+    this.idempotencyKey = idempotencyKey;
+  }
+  taskId;
+  subtaskId;
+  action;
+  agentNid;
+  inputs;
+  params;
+  idempotencyKey;
+  frameType = 65 /* DELEGATE */;
+  preferredTier = 1 /* MSGPACK */;
+  toDict() {
+    return {
+      task_id: this.taskId,
+      subtask_id: this.subtaskId,
+      action: this.action,
+      agent_nid: this.agentNid,
+      inputs: this.inputs ?? null,
+      params: this.params ?? null,
+      idempotency_key: this.idempotencyKey ?? null
+    };
+  }
+  static fromDict(data) {
+    return new _DelegateFrame(
+      data["task_id"],
+      data["subtask_id"],
+      data["action"],
+      data["agent_nid"],
+      data["inputs"] ?? void 0,
+      data["params"] ?? void 0,
+      data["idempotency_key"] ?? void 0
+    );
+  }
+};
+var SyncFrame = class _SyncFrame {
+  constructor(taskId, syncId, waitFor, minRequired = 0, aggregate = "merge", timeoutMs) {
+    this.taskId = taskId;
+    this.syncId = syncId;
+    this.waitFor = waitFor;
+    this.minRequired = minRequired;
+    this.aggregate = aggregate;
+    this.timeoutMs = timeoutMs;
+  }
+  taskId;
+  syncId;
+  waitFor;
+  minRequired;
+  aggregate;
+  timeoutMs;
+  frameType = 66 /* SYNC */;
+  preferredTier = 1 /* MSGPACK */;
+  toDict() {
+    return {
+      task_id: this.taskId,
+      sync_id: this.syncId,
+      wait_for: this.waitFor,
+      min_required: this.minRequired,
+      aggregate: this.aggregate,
+      timeout_ms: this.timeoutMs ?? null
+    };
+  }
+  static fromDict(data) {
+    return new _SyncFrame(
+      data["task_id"],
+      data["sync_id"],
+      data["wait_for"],
+      data["min_required"] ?? 0,
+      data["aggregate"] ?? "merge",
+      data["timeout_ms"] ?? void 0
+    );
+  }
+};
+var AlignStreamFrame = class _AlignStreamFrame {
+  constructor(streamId, taskId, subtaskId, seq, isFinal, senderNid, data, error, windowSize) {
+    this.streamId = streamId;
+    this.taskId = taskId;
+    this.subtaskId = subtaskId;
+    this.seq = seq;
+    this.isFinal = isFinal;
+    this.senderNid = senderNid;
+    this.data = data;
+    this.error = error;
+    this.windowSize = windowSize;
+  }
+  streamId;
+  taskId;
+  subtaskId;
+  seq;
+  isFinal;
+  senderNid;
+  data;
+  error;
+  windowSize;
+  frameType = 67 /* ALIGN_STREAM */;
+  preferredTier = 1 /* MSGPACK */;
+  toDict() {
+    return {
+      stream_id: this.streamId,
+      task_id: this.taskId,
+      subtask_id: this.subtaskId,
+      seq: this.seq,
+      is_final: this.isFinal,
+      sender_nid: this.senderNid,
+      data: this.data ?? null,
+      error: this.error ? { error_code: this.error.errorCode, message: this.error.message ?? null } : null,
+      window_size: this.windowSize ?? null
+    };
+  }
+  static fromDict(data) {
+    const rawError = data["error"];
+    return new _AlignStreamFrame(
+      data["stream_id"],
+      data["task_id"],
+      data["subtask_id"],
+      data["seq"],
+      data["is_final"],
+      data["sender_nid"],
+      data["data"] ?? void 0,
+      rawError ? { errorCode: rawError.error_code, ...rawError.message != null ? { message: rawError.message } : {} } : void 0,
+      data["window_size"] ?? void 0
+    );
+  }
+};
+
+// src/nop/registry.ts
+function registerNopFrames(registry) {
+  registry.register(64 /* TASK */, TaskFrame);
+  registry.register(65 /* DELEGATE */, DelegateFrame);
+  registry.register(66 /* SYNC */, SyncFrame);
+  registry.register(67 /* ALIGN_STREAM */, AlignStreamFrame);
+}
+var Tier1JsonCodec = class {
+  encode(frame) {
+    try {
+      const json = JSON.stringify(frame.toDict());
+      return new TextEncoder().encode(json);
+    } catch (err) {
+      throw new NpsCodecError(
+        `Tier-1 JSON encode failed for 0x${frame.frameType.toString(16).padStart(2, "0")}: ${String(err)}`
+      );
+    }
+  }
+  decode(frameType, payload, registry) {
+    const cls = registry.resolve(frameType);
+    try {
+      const text = new TextDecoder().decode(payload);
+      const data = JSON.parse(text);
+      return cls.fromDict(data);
+    } catch (err) {
+      throw new NpsCodecError(
+        `Tier-1 JSON decode failed for 0x${frameType.toString(16).padStart(2, "0")}: ${String(err)}`
+      );
+    }
+  }
+};
+var Tier2MsgPackCodec = class {
+  encode(frame) {
+    try {
+      return msgpack__namespace.encode(frame.toDict());
+    } catch (err) {
+      throw new NpsCodecError(
+        `Tier-2 MsgPack encode failed for 0x${frame.frameType.toString(16).padStart(2, "0")}: ${String(err)}`
+      );
+    }
+  }
+  decode(frameType, payload, registry) {
+    const cls = registry.resolve(frameType);
+    try {
+      const data = msgpack__namespace.decode(payload);
+      return cls.fromDict(data);
+    } catch (err) {
+      throw new NpsCodecError(
+        `Tier-2 MsgPack decode failed for 0x${frameType.toString(16).padStart(2, "0")}: ${String(err)}`
+      );
+    }
+  }
+};
+var NpsFrameCodec = class {
+  _registry;
+  _maxPayload;
+  _json = new Tier1JsonCodec();
+  _msgpack = new Tier2MsgPackCodec();
+  constructor(registry, options = {}) {
+    this._registry = registry;
+    this._maxPayload = options.maxPayload ?? DEFAULT_MAX_PAYLOAD;
+  }
+  // ── Encode ────────────────────────────────────────────────────────────────
+  encode(frame, options = {}) {
+    const tier = options.overrideTier ?? frame.preferredTier;
+    const tierCodec = this._selectCodec(tier);
+    let payload;
+    try {
+      payload = tierCodec.encode(frame);
+    } catch (err) {
+      if (err instanceof NpsCodecError) throw err;
+      throw new NpsCodecError(`Encode failed for 0x${frame.frameType.toString(16)}.`);
+    }
+    if (payload.length > this._maxPayload) {
+      throw new NpsCodecError(
+        `Encoded payload for 0x${frame.frameType.toString(16).padStart(2, "0")} exceeds max_frame_payload (${payload.length} bytes > ${this._maxPayload}). Use StreamFrame (0x03) for large payloads.`
+      );
+    }
+    const useExt = payload.length > DEFAULT_MAX_PAYLOAD;
+    let flags = this._buildFlags(frame, tier);
+    if (useExt) flags |= FrameFlags.EXT;
+    const header = new FrameHeader(frame.frameType, flags, payload.length);
+    const headerBytes = header.toBytes();
+    const wire = new Uint8Array(headerBytes.length + payload.length);
+    wire.set(headerBytes, 0);
+    wire.set(payload, headerBytes.length);
+    return wire;
+  }
+  // ── Decode ────────────────────────────────────────────────────────────────
+  decode(wire) {
+    const header = FrameHeader.parse(wire);
+    const payload = wire.slice(header.headerSize, header.headerSize + header.payloadLength);
+    const codec = this._selectCodec(header.encodingTier);
+    return codec.decode(header.frameType, payload, this._registry);
+  }
+  static peekHeader(wire) {
+    return FrameHeader.parse(wire);
+  }
+  // ── Private ───────────────────────────────────────────────────────────────
+  _buildFlags(frame, tier) {
+    let flags = tier === 0 /* JSON */ ? FrameFlags.TIER1_JSON : FrameFlags.TIER2_MSGPACK;
+    const isStreamFrame = "isLast" in frame;
+    const isFinal = !isStreamFrame || frame.isLast;
+    if (isFinal) flags |= FrameFlags.FINAL;
+    return flags;
+  }
+  _selectCodec(tier) {
+    if (tier === 0 /* JSON */) return this._json;
+    if (tier === 1 /* MSGPACK */) return this._msgpack;
+    throw new NpsCodecError(`Unsupported encoding tier: 0x${tier.toString(16).padStart(2, "0")}.`);
+  }
+};
+
+// src/core/registry.ts
+var FrameRegistry = class {
+  _map = /* @__PURE__ */ new Map();
+  register(frameType, cls) {
+    this._map.set(frameType, cls);
+  }
+  resolve(frameType) {
+    const cls = this._map.get(frameType);
+    if (cls === void 0) {
+      throw new NpsFrameError(
+        `No frame class registered for type 0x${frameType.toString(16).padStart(2, "0")}.`
+      );
+    }
+    return cls;
+  }
+};
+
+// src/ncp/frames.ts
+var AnchorFrame = class _AnchorFrame {
+  constructor(anchorId, schema, ttl = 3600) {
+    this.anchorId = anchorId;
+    this.schema = schema;
+    this.ttl = ttl;
+  }
+  anchorId;
+  schema;
+  ttl;
+  frameType = 1 /* ANCHOR */;
+  preferredTier = 1 /* MSGPACK */;
+  toDict() {
+    return {
+      anchor_id: this.anchorId,
+      schema: { fields: this.schema.fields.map((f) => ({ ...f })) },
+      ttl: this.ttl
+    };
+  }
+  static fromDict(data) {
+    const schemaRaw = data["schema"];
+    return new _AnchorFrame(
+      data["anchor_id"],
+      { fields: schemaRaw.fields },
+      data["ttl"] ?? 3600
+    );
+  }
+};
+var DiffFrame = class _DiffFrame {
+  constructor(anchorRef, baseSeq, patch, entityId) {
+    this.anchorRef = anchorRef;
+    this.baseSeq = baseSeq;
+    this.patch = patch;
+    this.entityId = entityId;
+  }
+  anchorRef;
+  baseSeq;
+  patch;
+  entityId;
+  frameType = 2 /* DIFF */;
+  preferredTier = 1 /* MSGPACK */;
+  toDict() {
+    return {
+      anchor_ref: this.anchorRef,
+      base_seq: this.baseSeq,
+      patch: this.patch.map((p) => ({ ...p })),
+      entity_id: this.entityId ?? null
+    };
+  }
+  static fromDict(data) {
+    return new _DiffFrame(
+      data["anchor_ref"],
+      data["base_seq"],
+      data["patch"],
+      data["entity_id"] ?? void 0
+    );
+  }
+};
+var StreamFrame = class _StreamFrame {
+  constructor(streamId, seq, isLast, data, anchorRef, windowSize) {
+    this.streamId = streamId;
+    this.seq = seq;
+    this.isLast = isLast;
+    this.data = data;
+    this.anchorRef = anchorRef;
+    this.windowSize = windowSize;
+  }
+  streamId;
+  seq;
+  isLast;
+  data;
+  anchorRef;
+  windowSize;
+  frameType = 3 /* STREAM */;
+  preferredTier = 1 /* MSGPACK */;
+  toDict() {
+    return {
+      stream_id: this.streamId,
+      seq: this.seq,
+      is_last: this.isLast,
+      data: this.data,
+      anchor_ref: this.anchorRef ?? null,
+      window_size: this.windowSize ?? null
+    };
+  }
+  static fromDict(data) {
+    return new _StreamFrame(
+      data["stream_id"],
+      data["seq"],
+      data["is_last"],
+      data["data"],
+      data["anchor_ref"] ?? void 0,
+      data["window_size"] ?? void 0
+    );
+  }
+};
+var CapsFrame = class _CapsFrame {
+  constructor(anchorRef, count, data, nextCursor, tokenEst, cached, tokenizerUsed) {
+    this.anchorRef = anchorRef;
+    this.count = count;
+    this.data = data;
+    this.nextCursor = nextCursor;
+    this.tokenEst = tokenEst;
+    this.cached = cached;
+    this.tokenizerUsed = tokenizerUsed;
+  }
+  anchorRef;
+  count;
+  data;
+  nextCursor;
+  tokenEst;
+  cached;
+  tokenizerUsed;
+  frameType = 4 /* CAPS */;
+  preferredTier = 1 /* MSGPACK */;
+  toDict() {
+    return {
+      anchor_ref: this.anchorRef,
+      count: this.count,
+      data: this.data,
+      next_cursor: this.nextCursor ?? null,
+      token_est: this.tokenEst ?? null,
+      cached: this.cached ?? null,
+      tokenizer_used: this.tokenizerUsed ?? null
+    };
+  }
+  static fromDict(data) {
+    return new _CapsFrame(
+      data["anchor_ref"],
+      data["count"],
+      data["data"],
+      data["next_cursor"] ?? void 0,
+      data["token_est"] ?? void 0,
+      data["cached"] ?? void 0,
+      data["tokenizer_used"] ?? void 0
+    );
+  }
+};
+var ErrorFrame = class _ErrorFrame {
+  constructor(status, error, message, details) {
+    this.status = status;
+    this.error = error;
+    this.message = message;
+    this.details = details;
+  }
+  status;
+  error;
+  message;
+  details;
+  frameType = 254 /* ERROR */;
+  preferredTier = 1 /* MSGPACK */;
+  toDict() {
+    return {
+      status: this.status,
+      error: this.error,
+      message: this.message ?? null,
+      details: this.details ?? null
+    };
+  }
+  static fromDict(data) {
+    return new _ErrorFrame(
+      data["status"],
+      data["error"],
+      data["message"] ?? void 0,
+      data["details"] ?? void 0
+    );
+  }
+};
+
+// src/ncp/registry.ts
+function registerNcpFrames(registry) {
+  registry.register(1 /* ANCHOR */, AnchorFrame);
+  registry.register(2 /* DIFF */, DiffFrame);
+  registry.register(3 /* STREAM */, StreamFrame);
+  registry.register(4 /* CAPS */, CapsFrame);
+  registry.register(254 /* ERROR */, ErrorFrame);
+}
+
+// src/nop/client.ts
+var TERMINAL_STATES = /* @__PURE__ */ new Set([
+  "completed" /* COMPLETED */,
+  "failed" /* FAILED */,
+  "cancelled" /* CANCELLED */
+]);
+var NopTaskStatus = class {
+  constructor(_raw) {
+    this._raw = _raw;
+  }
+  _raw;
+  get taskId() {
+    return this._raw["task_id"];
+  }
+  get state() {
+    return this._raw["state"];
+  }
+  get isTerminal() {
+    return TERMINAL_STATES.has(this._raw["state"]);
+  }
+  get aggregatedResult() {
+    return this._raw["aggregated_result"];
+  }
+  get errorCode() {
+    return this._raw["error_code"] ?? void 0;
+  }
+  get errorMessage() {
+    return this._raw["error_message"] ?? void 0;
+  }
+  get nodeResults() {
+    return this._raw["node_results"] ?? {};
+  }
+  get raw() {
+    return this._raw;
+  }
+  toString() {
+    return `NopTaskStatus(taskId=${this.taskId}, state=${String(this._raw["state"])})`;
+  }
+};
+var NopClient = class {
+  _baseUrl;
+  _codec;
+  _tier;
+  constructor(baseUrl, options = {}) {
+    this._baseUrl = baseUrl.replace(/\/$/, "");
+    this._tier = options.defaultTier ?? 1 /* MSGPACK */;
+    const registry = options.registry ?? (() => {
+      const r = new FrameRegistry();
+      registerNcpFrames(r);
+      registerNopFrames(r);
+      return r;
+    })();
+    this._codec = new NpsFrameCodec(registry);
+  }
+  async submit(frame) {
+    const wire = this._codec.encode(frame, { overrideTier: this._tier });
+    const res = await fetch(`${this._baseUrl}/task`, {
+      method: "POST",
+      body: wire,
+      headers: { "Content-Type": "application/x-nps-frame", "Accept": "application/json" }
+    });
+    if (!res.ok) throw new Error(`NOP /task failed: HTTP ${res.status}`);
+    const data = await res.json();
+    return data["task_id"];
+  }
+  async getStatus(taskId) {
+    const res = await fetch(`${this._baseUrl}/task/${taskId}`, {
+      headers: { "Accept": "application/json" }
+    });
+    if (!res.ok) throw new Error(`NOP /task/${taskId} failed: HTTP ${res.status}`);
+    return new NopTaskStatus(await res.json());
+  }
+  async cancel(taskId) {
+    const res = await fetch(`${this._baseUrl}/task/${taskId}/cancel`, {
+      method: "POST",
+      headers: { "Accept": "application/json" }
+    });
+    if (!res.ok) throw new Error(`NOP /task/${taskId}/cancel failed: HTTP ${res.status}`);
+  }
+  async wait(taskId, options = {}) {
+    const pollIntervalMs = options.pollIntervalMs ?? 1e3;
+    const timeoutMs = options.timeoutMs ?? 3e4;
+    const deadline = Date.now() + timeoutMs;
+    while (true) {
+      const status = await this.getStatus(taskId);
+      if (status.isTerminal) return status;
+      const remaining = deadline - Date.now();
+      if (remaining <= 0) {
+        throw new Error(`Task '${taskId}' did not complete within ${timeoutMs}ms (state: ${String(status.raw["state"])}).`);
+      }
+      await new Promise((resolve) => setTimeout(resolve, Math.min(pollIntervalMs, remaining)));
+    }
+  }
+};
+
+exports.AggregateStrategy = AggregateStrategy;
+exports.AlignStreamFrame = AlignStreamFrame;
+exports.BackoffStrategy = BackoffStrategy;
+exports.DelegateFrame = DelegateFrame;
+exports.NopClient = NopClient;
+exports.NopTaskStatus = NopTaskStatus;
+exports.SyncFrame = SyncFrame;
+exports.TaskFrame = TaskFrame;
+exports.TaskPriority = TaskPriority;
+exports.TaskState = TaskState;
+exports.computeDelayMs = computeDelayMs;
+exports.registerNopFrames = registerNopFrames;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map