@shelby-protocol/sdk 0.3.1 → 0.4.0

package/dist/core/sp/sp_write_client.mjs

@@ -0,0 +1,302 @@
+// src/core/sp/sp_write_client.ts
+import * as net from "net";
+import { create, fromBinary, toBinary } from "@bufbuild/protobuf";
+
+// src/gen/rpc_server_pb.ts
+import { fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv2";
+var file_rpc_server = /* @__PURE__ */ fileDesc("ChBycGNfc2VydmVyLnByb3RvEgNjYXYiGgoHUGF5bWVudBIPCgdwYXltZW50GAEgASgMIhkKCVByb29mTm9kZRIMCgRoYXNoGAEgASgMIiwKBVByb29mEiMKC3Byb29mX25vZGVzGAEgAygLMg4uY2F2LlByb29mTm9kZSJFCghDaHVua0tleRIQCghibG9iX3VpZBgBIAEoBBIUCgxjaHVua3NldF9pZHgYAiABKA0SEQoJY2h1bmtfaWR4GAMgASgNIk8KC1JlYWRSZXF1ZXN0EiEKCmlkZW50aWZpZXIYASABKAsyDS5jYXYuQ2h1bmtLZXkSHQoHcGF5bWVudBgCIAEoCzIMLmNhdi5QYXltZW50InEKGUNsYXlIZWxwZXJEYXRhUmVhZFJlcXVlc3QSIQoKaWRlbnRpZmllchgBIAEoCzINLmNhdi5DaHVua0tleRIYChB0YXJnZXRfY2h1bmtfaWR4GAIgASgNEhcKD2hlbHBlcl9zZXRfbWFzaxgDIAEoBCJgCgxXcml0ZVJlcXVlc3QSIQoKaWRlbnRpZmllchgBIAEoCzINLmNhdi5DaHVua0tleRIMCgRib2R5GAIgASgMEhkKBXByb29mGAMgASgLMgouY2F2LlByb29mSgQIBBAFIsQBCgdSZXF1ZXN0EiQKCHJlYWRfcmVxGAEgASgLMhAuY2F2LlJlYWRSZXF1ZXN0SAASJgoJd3JpdGVfcmVxGAIgASgLMhEuY2F2LldyaXRlUmVxdWVzdEgAEjkKD2hlbHBlcl9yZWFkX3JlcRgFIAEoCzIeLmNhdi5DbGF5SGVscGVyRGF0YVJlYWRSZXF1ZXN0SAASEgoKcmVxdWVzdF9pZBgDIAEoBBIRCglzaWduYXR1cmUYBCABKAxCCQoHcmVxdWVzdCJXCgxSZWFkUmVzcG9uc2USDAoEYm9keRgBIAEoDBIZCgVwcm9vZhgCIAEoCzIKLmNhdi5Qcm9vZhIeChZoZWxwZXJfY2h1bmtfcm9vdF9oYXNoGAMgASgMIk0KDVdyaXRlUmVzcG9uc2USGgoSYmxvYl9hY2tfc2lnbmF0dXJlGAIgASgMEiAKGG1pc3NpbmdfY2h1bmtzZXRfaW5kaWNlcxgDIAMoDSKWAQoIUmVzcG9uc2USEgoKcmVxdWVzdF9pZBgBIAEoBBISCgplcnJvcl9jb2RlGAIgASgEEiYKCXJlYWRfcmVzcBgDIAEoCzIRLmNhdi5SZWFkUmVzcG9uc2VIABIoCgp3cml0ZV9yZXNwGAQgASgLMhIuY2F2LldyaXRlUmVzcG9uc2VIAEIKCghyZXNwb25zZUoECAUQBmIGcHJvdG8z");
+var ProofNodeSchema = /* @__PURE__ */ messageDesc(file_rpc_server, 1);
+var ProofSchema = /* @__PURE__ */ messageDesc(file_rpc_server, 2);
+var ChunkKeySchema = /* @__PURE__ */ messageDesc(file_rpc_server, 3);
+var ReadRequestSchema = /* @__PURE__ */ messageDesc(file_rpc_server, 4);
+var WriteRequestSchema = /* @__PURE__ */ messageDesc(file_rpc_server, 6);
+var RequestSchema = /* @__PURE__ */ messageDesc(file_rpc_server, 7);
+var ResponseSchema = /* @__PURE__ */ messageDesc(file_rpc_server, 10);
+
+// src/core/sp/chunk_proof.ts
+import { createHash } from "crypto";
+
+// src/core/utils.ts
+import {
+  AccountAddress,
+  Hex
+} from "@aptos-labs/ts-sdk";
+
+// src/core/sp/chunk_proof.ts
+var SP_WRITE_SUCCESS_ERROR_CODE = 1n;
+
+// src/core/sp/sp_write_client.ts
+var SP_CLIENT_LOG = process.env.SHELBY_SP_CLIENT_LOG === "1";
+var DEFAULT_REQUEST_TIMEOUT_MS = 3e4;
+var DEFAULT_CONNECTIONS = 4;
+var SpWriteClient = class {
+  constructor(host, port, numConnections = DEFAULT_CONNECTIONS, requestTimeoutMs = DEFAULT_REQUEST_TIMEOUT_MS) {
+    this.host = host;
+    this.port = port;
+    this.numConnections = numConnections;
+    this.requestTimeoutMs = requestTimeoutMs;
+  }
+  connections = [];
+  nextConnectionIdx = 0;
+  nextRequestId = 1n;
+  connected = false;
+  async connect() {
+    if (this.connected) {
+      return;
+    }
+    const connectPromises = [];
+    for (let i = 0; i < this.numConnections; i++) {
+      connectPromises.push(this.createConnection());
+    }
+    await Promise.all(connectPromises);
+    this.connected = true;
+  }
+  createConnection() {
+    return new Promise((resolve, reject) => {
+      const socket = new net.Socket();
+      let settled = false;
+      const state = {
+        socket,
+        responseBuffer: Buffer.alloc(0),
+        expectedSize: null,
+        pending: /* @__PURE__ */ new Map(),
+        writeQueue: [],
+        draining: false,
+        closed: false
+      };
+      socket.on("connect", () => {
+        this.connections.push(state);
+        settled = true;
+        resolve();
+      });
+      socket.on("data", (data) => {
+        this.handleData(state, data);
+      });
+      socket.on("error", (err) => {
+        if (SP_CLIENT_LOG)
+          console.error(
+            `[SpWriteClient] socket error ${this.host}:${this.port}: ${err.message}`
+          );
+        if (!settled) {
+          settled = true;
+          reject(err);
+        }
+        this.handleDisconnect(state, err);
+      });
+      socket.on("close", (hadError) => {
+        if (SP_CLIENT_LOG)
+          console.error(
+            `[SpWriteClient] socket closed ${this.host}:${this.port} (hadError=${hadError})`
+          );
+        this.handleDisconnect(state, new Error("SP connection closed"));
+      });
+      socket.on("timeout", () => {
+        if (SP_CLIENT_LOG)
+          console.error(
+            `[SpWriteClient] socket idle timeout ${this.host}:${this.port} after ${this.requestTimeoutMs}ms`
+          );
+        socket.destroy(new Error("SP connection timed out"));
+      });
+      socket.connect(this.port, this.host);
+    });
+  }
+  handleData(state, data) {
+    state.responseBuffer = Buffer.concat([state.responseBuffer, data]);
+    while (true) {
+      if (state.expectedSize === null) {
+        if (state.responseBuffer.length < 8) {
+          return;
+        }
+        state.expectedSize = Number(state.responseBuffer.readBigUInt64LE(0));
+      }
+      const totalNeeded = 8 + state.expectedSize;
+      if (state.responseBuffer.length < totalNeeded) {
+        return;
+      }
+      const responseBytes = state.responseBuffer.subarray(8, totalNeeded);
+      state.responseBuffer = state.responseBuffer.subarray(totalNeeded);
+      state.expectedSize = null;
+      try {
+        const response = fromBinary(ResponseSchema, responseBytes);
+        const pending = state.pending.get(response.requestId);
+        if (pending) {
+          clearTimeout(pending.timeoutId);
+          state.pending.delete(response.requestId);
+          const success = response.errorCode === SP_WRITE_SUCCESS_ERROR_CODE;
+          if (pending.resolver.kind === "write") {
+            const blobAckSignature = response.response.case === "writeResp" ? response.response.value.blobAckSignature : new Uint8Array(0);
+            pending.resolver.resolve({
+              success,
+              errorCode: response.errorCode,
+              blobAckSignature
+            });
+          } else {
+            const body = response.response.case === "readResp" ? response.response.value.body : new Uint8Array(0);
+            pending.resolver.resolve({
+              success,
+              errorCode: response.errorCode,
+              bytesRead: body.byteLength
+            });
+          }
+        }
+      } catch (error) {
+        for (const [, pending] of state.pending) {
+          clearTimeout(pending.timeoutId);
+          pending.reject(
+            error instanceof Error ? error : new Error(String(error))
+          );
+        }
+        state.pending.clear();
+      }
+    }
+  }
+  handleDisconnect(state, error) {
+    if (state.closed) {
+      return;
+    }
+    state.closed = true;
+    for (const [, pending] of state.pending) {
+      clearTimeout(pending.timeoutId);
+      pending.reject(error);
+    }
+    state.pending.clear();
+    const idx = this.connections.indexOf(state);
+    if (idx !== -1) {
+      this.connections.splice(idx, 1);
+    }
+  }
+  drainConnection(state) {
+    if (state.draining || state.writeQueue.length === 0 || state.closed) {
+      return;
+    }
+    state.draining = true;
+    const frame = state.writeQueue.shift();
+    const canContinue = state.socket.write(frame, () => {
+      state.draining = false;
+      this.drainConnection(state);
+    });
+    if (!canContinue) {
+      state.socket.once("drain", () => {
+        state.draining = false;
+        this.drainConnection(state);
+      });
+    } else {
+      state.draining = false;
+      this.drainConnection(state);
+    }
+  }
+  selectConnection() {
+    if (this.connections.length === 0) {
+      throw new Error("Not connected to SP");
+    }
+    for (let i = 0; i < this.connections.length; i++) {
+      const idx = (this.nextConnectionIdx + i) % this.connections.length;
+      const conn = this.connections[idx];
+      if (!conn.closed) {
+        this.nextConnectionIdx = (idx + 1) % this.connections.length;
+        return conn;
+      }
+    }
+    throw new Error("No available SP connections");
+  }
+  async writeChunk(params) {
+    if (!this.connected) {
+      await this.connect();
+    }
+    const conn = this.selectConnection();
+    const requestId = this.nextRequestId++;
+    const chunkKey = create(ChunkKeySchema, {
+      blobUid: params.blobUid,
+      chunksetIdx: params.chunksetIdx,
+      chunkIdx: params.chunkIdx
+    });
+    const proofNodes = [];
+    for (let i = 0; i < params.proof.length; i += 32) {
+      proofNodes.push(
+        create(ProofNodeSchema, {
+          hash: params.proof.slice(i, i + 32)
+        })
+      );
+    }
+    const request = create(RequestSchema, {
+      request: {
+        case: "writeReq",
+        value: create(WriteRequestSchema, {
+          identifier: chunkKey,
+          body: params.chunkData,
+          proof: create(ProofSchema, { proofNodes })
+        })
+      },
+      requestId,
+      signature: new Uint8Array(64)
+    });
+    const requestBytes = toBinary(RequestSchema, request);
+    const lengthBuffer = Buffer.alloc(8);
+    lengthBuffer.writeBigUInt64LE(BigInt(requestBytes.length), 0);
+    const frame = Buffer.concat([lengthBuffer, Buffer.from(requestBytes)]);
+    return new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        conn.pending.delete(requestId);
+        reject(new Error(`SP write request ${requestId} timed out`));
+      }, this.requestTimeoutMs);
+      conn.pending.set(requestId, {
+        resolver: { kind: "write", resolve },
+        reject,
+        timeoutId
+      });
+      conn.writeQueue.push(frame);
+      this.drainConnection(conn);
+    });
+  }
+  async readChunk(params) {
+    if (!this.connected) {
+      await this.connect();
+    }
+    const conn = this.selectConnection();
+    const requestId = this.nextRequestId++;
+    const chunkKey = create(ChunkKeySchema, {
+      blobUid: params.blobUid,
+      chunksetIdx: params.chunksetIdx,
+      chunkIdx: params.chunkIdx
+    });
+    const request = create(RequestSchema, {
+      request: {
+        case: "readReq",
+        value: create(ReadRequestSchema, {
+          identifier: chunkKey
+        })
+      },
+      requestId,
+      signature: new Uint8Array(64)
+    });
+    const requestBytes = toBinary(RequestSchema, request);
+    const lengthBuffer = Buffer.alloc(8);
+    lengthBuffer.writeBigUInt64LE(BigInt(requestBytes.length), 0);
+    const frame = Buffer.concat([lengthBuffer, Buffer.from(requestBytes)]);
+    return new Promise((resolve, reject) => {
+      const timeoutId = setTimeout(() => {
+        conn.pending.delete(requestId);
+        reject(new Error(`SP read request ${requestId} timed out`));
+      }, this.requestTimeoutMs);
+      conn.pending.set(requestId, {
+        resolver: { kind: "read", resolve },
+        reject,
+        timeoutId
+      });
+      conn.writeQueue.push(frame);
+      this.drainConnection(conn);
+    });
+  }
+  // biome-ignore lint/suspicious/useAwait: callers rely on Promise return
+  async close() {
+    this.connected = false;
+    for (const conn of this.connections) {
+      conn.closed = true;
+      conn.socket.destroy();
+    }
+    this.connections = [];
+  }
+};
+export {
+  SpWriteClient
+};

package/dist/core/types/blobs.d.ts

@@ -21,12 +21,25 @@ type ClayEncoding = Required<ClayProviderOptions & {
  * @link https://github.com/shelby/shelby/blob/e08e84742cf2b80ad8bb7227deb3013398076d53/move/shelby_contract/sources/common_types.move#L32
  */
 type BlobEncoding = ClayEncoding;
+/**
+ * The encryption scheme a blob's contents were registered with. Mirrors the
+ * on-chain `blob_metadata::EncryptionScheme` variants.
+ */
+type BlobEncryption = "Unencrypted" | "AES_GCM_V1";
+type BlobEncryptionMoveEnumIndex = 0 | 1;
+declare function blobEncryptionToMoveEnumIndex(encryption: BlobEncryption): BlobEncryptionMoveEnumIndex;
+declare function blobEncryptionFromMoveVariant(variant: string): BlobEncryption;
 /**
  * The metadata of a blob that describes the blob and its properties.
- *
- * @link https://github.com/shelby/shelby/blob/e08e84742cf2b80ad8bb7227deb3013398076d53/move/shelby_contract/sources/global_metadata.move#L185
  */
-interface BlobMetadata {
+interface FullObjectMetadata {
+    /**
+     * The on-chain UID the object name currently resolves to. Populated on both
+     * the view path (`get_full_object_metadata`) and the indexer path (the
+     * committed row's `uid`). Optional only for callers constructing metadata by
+     * hand.
+     */
+    uid?: bigint;
     /**
      * The owner of the blob.
      */
@@ -56,6 +69,12 @@ interface BlobMetadata {
      * The encoding of the blob.
      */
     encoding: BlobEncoding;
+    /**
+     * The encryption scheme the blob was registered with. Present from the
+     * on-chain view path; absent for indexer-sourced metadata, which does not
+     * yet surface it.
+     */
+    encryption?: BlobEncryption;
     /**
      * The expiration timestamp of the blob in microseconds.
      */
@@ -77,7 +96,7 @@ interface BlobMetadata {
      */
     isDeleted?: boolean;
 }
-type BlobActivityType = "register_blob" | "delete_blob" | "extend_blob_expiration" | "write_blob" | "unknown";
+type BlobActivityType = "register_blob" | "delete_blob" | "extend_blob_expiration" | "write_blob" | "commit_object" | "delete_object" | "reject_object_commit" | "unknown";
 /**
  * The activity of a blob.
  */
@@ -129,4 +148,4 @@ interface StorageProviderAck {
     signature: Uint8Array;
 }
 
-export type { BlobActivity, BlobActivityType, BlobEncoding, BlobMetadata, ClayEncoding, StorageProviderAck };
+export { type BlobActivity, type BlobActivityType, type BlobEncoding, type BlobEncryption, type BlobEncryptionMoveEnumIndex, type ClayEncoding, type FullObjectMetadata, type StorageProviderAck, blobEncryptionFromMoveVariant, blobEncryptionToMoveEnumIndex };

package/dist/core/types/blobs.mjs

@@ -0,0 +1,24 @@
+// src/core/types/blobs.ts
+var BLOB_ENCRYPTION_TO_MOVE_ENUM_INDEX = {
+  Unencrypted: 0,
+  AES_GCM_V1: 1
+};
+function blobEncryptionToMoveEnumIndex(encryption) {
+  return BLOB_ENCRYPTION_TO_MOVE_ENUM_INDEX[encryption];
+}
+function blobEncryptionFromMoveVariant(variant) {
+  switch (variant) {
+    case "Unencrypted":
+      return "Unencrypted";
+    case "AES_GCM_V1":
+      return "AES_GCM_V1";
+    default:
+      throw new Error(
+        "Could not parse encryption from Shelby Smart Contract, this SDK is out of date."
+      );
+  }
+}
+export {
+  blobEncryptionFromMoveVariant,
+  blobEncryptionToMoveEnumIndex
+};

package/dist/core/types/index.d.ts

@@ -1,7 +1,7 @@
-export { BlobActivity, BlobActivityType, BlobEncoding, BlobMetadata, ClayEncoding, StorageProviderAck } from './blobs.js';
+export { BlobActivity, BlobActivityType, BlobEncoding, BlobEncryption, BlobEncryptionMoveEnumIndex, ClayEncoding, FullObjectMetadata, StorageProviderAck, blobEncryptionFromMoveVariant, blobEncryptionToMoveEnumIndex } from './blobs.js';
 export { ChannelInfo, SenderBuiltMicropayment, StaleChannelStateError } from './payments.js';
 export { PlacementGroupInfo, PlacementGroupSlot, PlacementGroupSlotStatus } from './placement_groups.js';
-export { ActiveStateDetails, FrozenStateDetails, StorageProviderInfo, StorageProviderStateDetails, WaitlistedStateDetails } from './storage_providers.js';
+export { ActiveProviderCondition, ActiveStateDetails, FrozenStateDetails, StorageProviderInfo, StorageProviderStateDetails, WaitlistedStateDetails, isActiveForTasks, isActiveProviderCondition } from './storage_providers.js';
 import '@aptos-labs/ts-sdk';
 import '../../clay-codes-DdXABBDx.js';
 import '@shelby-protocol/clay-codes';

package/dist/core/types/index.mjs

@@ -1,3 +1,24 @@
+// src/core/types/blobs.ts
+var BLOB_ENCRYPTION_TO_MOVE_ENUM_INDEX = {
+  Unencrypted: 0,
+  AES_GCM_V1: 1
+};
+function blobEncryptionToMoveEnumIndex(encryption) {
+  return BLOB_ENCRYPTION_TO_MOVE_ENUM_INDEX[encryption];
+}
+function blobEncryptionFromMoveVariant(variant) {
+  switch (variant) {
+    case "Unencrypted":
+      return "Unencrypted";
+    case "AES_GCM_V1":
+      return "AES_GCM_V1";
+    default:
+      throw new Error(
+        "Could not parse encryption from Shelby Smart Contract, this SDK is out of date."
+      );
+  }
+}
+
 // src/core/types/payments.ts
 import {
   AccountAddress,
@@ -9,7 +30,7 @@ import {
 // src/core/constants.ts
 import { Network } from "@aptos-labs/ts-sdk";
 var NetworkToShelbyRPCBaseUrl = {
-  [Network.SHELBYNET]: "https://api.shelbynet.shelby.xyz/shelby",
+  [Network.SHELBYNET]: "https://shelby.shelbynet.shelby.xyz/shelby",
   [Network.NETNA]: void 0,
   [Network.DEVNET]: void 0,
   [Network.TESTNET]: "https://api.testnet.shelby.xyz/shelby",
@@ -229,7 +250,30 @@ var SenderBuiltMicropayment = class _SenderBuiltMicropayment {
     );
   }
 };
+
+// src/core/types/storage_providers.ts
+var ACTIVE_PROVIDER_CONDITIONS = [
+  "Normal",
+  "Faulty",
+  "Leaving",
+  "Evicted",
+  "PendingLeaving"
+];
+function isActiveProviderCondition(value) {
+  return typeof value === "string" && ACTIVE_PROVIDER_CONDITIONS.includes(value);
+}
+var TASK_ELIGIBLE_CONDITIONS = /* @__PURE__ */ new Set([
+  "Normal",
+  "PendingLeaving"
+]);
+function isActiveForTasks(condition) {
+  return TASK_ELIGIBLE_CONDITIONS.has(condition);
+}
 export {
   SenderBuiltMicropayment,
-  StaleChannelStateError
+  StaleChannelStateError,
+  blobEncryptionFromMoveVariant,
+  blobEncryptionToMoveEnumIndex,
+  isActiveForTasks,
+  isActiveProviderCondition
 };

package/dist/core/types/payments.mjs

@@ -9,7 +9,7 @@ import {
 // src/core/constants.ts
 import { Network } from "@aptos-labs/ts-sdk";
 var NetworkToShelbyRPCBaseUrl = {
-  [Network.SHELBYNET]: "https://api.shelbynet.shelby.xyz/shelby",
+  [Network.SHELBYNET]: "https://shelby.shelbynet.shelby.xyz/shelby",
   [Network.NETNA]: void 0,
   [Network.DEVNET]: void 0,
   [Network.TESTNET]: "https://api.testnet.shelby.xyz/shelby",

package/dist/core/types/storage_providers.d.ts

@@ -1,23 +1,49 @@
 import { AccountAddress } from '@aptos-labs/ts-sdk';
 
 /**
- * State details for active storage providers
+ * Variant names of `ActiveProviderCondition`. Single source of truth — the
+ * type below is derived from this tuple so adding a variant means editing
+ * one array.
+ *
+ * Mirrors the on-chain `ActiveProviderCondition` enum in
+ * `move/shelby_contract/sources/storage_provider_registry.move`. Keep in sync
+ * with the Move enum — the metadata-client parser fails closed (throws) on
+ * unknown variants so the mismatch surfaces immediately.
+ */
+declare const ACTIVE_PROVIDER_CONDITIONS: readonly ["Normal", "Faulty", "Leaving", "Evicted", "PendingLeaving"];
+/**
+ * Condition of an active storage provider.
+ */
+type ActiveProviderCondition = (typeof ACTIVE_PROVIDER_CONDITIONS)[number];
+/**
+ * Type guard for `ActiveProviderCondition` — used by the metadata-client
+ * parser to reject unknown wire-format variants.
+ */
+declare function isActiveProviderCondition(value: unknown): value is ActiveProviderCondition;
+/**
+ * Returns whether a condition is task-eligible. Mirrors Move's
+ * `is_active_for_tasks` in `storage_provider_registry.move` — adding a new
+ * task-eligible condition on-chain means updating the set above.
+ */
+declare function isActiveForTasks(condition: ActiveProviderCondition): boolean;
+/**
+ * State details for active storage providers.
  */
 interface ActiveStateDetails {
     variant: "Active";
+    /** FixedPoint64 serializes as string. */
     quota: string;
     stakeAtStartOfStakingEpoch: string;
-    faulty: boolean;
-    leaving: boolean;
+    condition: ActiveProviderCondition;
 }
 /**
- * State details for waitlisted storage providers
+ * State details for waitlisted storage providers.
  */
 interface WaitlistedStateDetails {
     variant: "Waitlisted";
 }
 /**
- * State details for frozen storage providers
+ * State details for frozen storage providers.
  */
 interface FrozenStateDetails {
     variant: "Frozen";
@@ -58,4 +84,4 @@ interface StorageProviderInfo {
     state: StorageProviderStateDetails;
 }
 
-export type { ActiveStateDetails, FrozenStateDetails, StorageProviderInfo, StorageProviderStateDetails, WaitlistedStateDetails };
+export { type ActiveProviderCondition, type ActiveStateDetails, type FrozenStateDetails, type StorageProviderInfo, type StorageProviderStateDetails, type WaitlistedStateDetails, isActiveForTasks, isActiveProviderCondition };

package/dist/core/types/storage_providers.mjs

@@ -0,0 +1,22 @@
+// src/core/types/storage_providers.ts
+var ACTIVE_PROVIDER_CONDITIONS = [
+  "Normal",
+  "Faulty",
+  "Leaving",
+  "Evicted",
+  "PendingLeaving"
+];
+function isActiveProviderCondition(value) {
+  return typeof value === "string" && ACTIVE_PROVIDER_CONDITIONS.includes(value);
+}
+var TASK_ELIGIBLE_CONDITIONS = /* @__PURE__ */ new Set([
+  "Normal",
+  "PendingLeaving"
+]);
+function isActiveForTasks(condition) {
+  return TASK_ELIGIBLE_CONDITIONS.has(condition);
+}
+export {
+  isActiveForTasks,
+  isActiveProviderCondition
+};