@invisible-labs/sdk 0.6.0-devnet.2 → 0.6.0-devnet.4

package/README.md

@@ -7,8 +7,11 @@ TypeScript SDK for building private SOL transfer integrations with Invisible.
 [API reference](https://docs.invisible.exchange/docs/sdk/reference/) ·
 [Trust model](https://docs.invisible.exchange/docs/security/)
 
-> Devnet beta. This release targets Solana devnet. APIs may change before a
-> stable release.
+> Devnet beta. This release targets Solana devnet. APIs may change before a stable release.
+
+This package is the programmatic entrypoint for user and LP interaction with an attested Invisible
+coordinator. The normal-user surface uses one functional sequence over a caller-owned session:
+`createSession`, `contractRequest`, `sync`, `requestRefund`, then `closeSession`.
 
 ## Install
 
@@ -16,86 +19,162 @@ TypeScript SDK for building private SOL transfer integrations with Invisible.
 npm install @invisible-labs/sdk@devnet
 ```
 
-## What the SDK provides
+## Session boundary
+
+The public artifact exposes a production-only root facade:
+
+```ts
+import { closeSession, createSession } from "@invisible-labs/sdk";
 
-- Attested coordinator sessions over WSS and Noise XX.
-- Private SOL transfer, status-sync, and refund flows.
-- Imports limited to the features an application needs.
-- Typed errors and runtime validation at protocol boundaries.
+const session = await createSession({
+  coordinatorUrl: "wss://tee-azure.invisible.exchange/ws-noise",
+});
+
+// Use the session with @invisible-labs/sdk/user or /lp, then:
+closeSession(session);
+```
+
+The public build embeds the approved production attestation tuple. It accepts a
+non-loopback `wss://` URL, but it does not accept `requiredMode`, a coordinator
+pool, release-pin overrides, or local-attestation controls. The private
+workspace build keeps the low-level pool constructor and exposes
+`createDevSession` for explicit local and test flows; that facade is not in the
+public artifact.
+
+`sdk.attestation.productionPolicy()` exposes the embedded tuple as read-only
+metadata. It is not a caller-controlled trust input.
 
 ## Entrypoints
 
-| Import                        | Purpose                                             |
-| ----------------------------- | --------------------------------------------------- |
-| `@invisible-labs/sdk`         | Session lifecycle, attestation, and shared controls |
-| `@invisible-labs/sdk/user`    | Private-transfer and refund flows                   |
-| `@invisible-labs/sdk/events`  | Sync subscriptions                                  |
-| `@invisible-labs/sdk/storage` | Client storage adapters                             |
+| Import                        | Covers                                                 |
+| ----------------------------- | ------------------------------------------------------ |
+| `@invisible-labs/sdk`         | `createSession`, attestation, and coordinator controls |
+| `@invisible-labs/sdk/user`    | normal-user commands: private transfer, sync, refund   |
+| `@invisible-labs/sdk/lp`      | liquidity-provider lifecycle                           |
+| `@invisible-labs/sdk/stats`   | actor-safe read projections                            |
+| `@invisible-labs/sdk/events`  | sync subscriptions                                     |
+| `@invisible-labs/sdk/storage` | storage adapters                                       |
+| `@invisible-labs/sdk/presets` | optional coordinator endpoint presets                  |
+
+Each actor entrypoint is independently importable; pulling one in must not drag the others into a
+consumer bundle. See [ARCHITECTURE.md](./ARCHITECTURE.md) for the layered module map.
 
 ## Private transfer
 
-Configure the coordinator from the current approved release information, then
-create a user session:
+The canonical normal-user flow uses one attested session and the functional SDK commands:
 
 ```ts
-import { normalizeError } from "@invisible-labs/sdk";
-import { createCoordinatorSession } from "@invisible-labs/sdk/user";
-
-const transfer = createCoordinatorSession({
-  coordinator,
-});
-
+import { closeSession, createSession } from "@invisible-labs/sdk";
+import {
+  contractRequest,
+  recoveryCodeFromHex,
+  requestRefund,
+  sync,
+} from "@invisible-labs/sdk/user";
+
+const coordinatorUrl = "wss://tee-azure.invisible.exchange/ws-noise";
+const payoutPolicy = {
+  destinations: [{ address: receiverPublicKey, sharePercent: 100 }],
+  totalDeadlineMs: 0,
+};
+
+const session = await createSession({ coordinatorUrl });
 try {
-  const result = await transfer.runSwap({
+  const contract = await contractRequest(session, {
     amountLamports: 3_000_000_000,
-    payoutSpec: {
-      mode: "instant",
-      destination_address: destinationAddress,
-    },
-    onSyncSecretReady({ secretHex }) {
-      saveSyncSecret(secretHex);
-    },
-    onRecoveryCodeReady({ codeHex }) {
-      saveRecoveryCode(codeHex);
-    },
-    onDepositAddressReady(deposit) {
-      showDepositInstructions(deposit);
-    },
+    payoutPolicy,
   });
-
-  console.log(result.swapId);
-} catch (error) {
-  console.error(normalizeError(error));
+  const status = await sync(session, contract.swapId, contract.syncSecret);
+  console.log(status.state, status.coordinatorTimestampMs);
+
+  if (status.actor_sync?.snapshot.refundability === "available_now") {
+    const receipt = await requestRefund(session, {
+      swapId: contract.swapId,
+      syncSecret: contract.syncSecret,
+      recoveryCode: recoveryCodeFromHex(contract.recoveryCodeHex!),
+    });
+    console.log(receipt.requestId, receipt.amountLamports);
+  }
 } finally {
-  transfer.close();
+  closeSession(session);
 }
 ```
 
-See the
-[private-transfer guide](https://docs.invisible.exchange/docs/sdk/private-transfer/)
-for funding, settlement events, scheduled receive, sync, and refunds.
+`contractRequest` resolves after durable delegation and before the deposit is observed. Its result
+contains `swapId`, `depositAddress`, `depositExpiresAtMs`, `syncSecret`, and the generated Recovery
+Code. Persist the sync secret and Recovery Code before asking the user to deposit. Send exactly
+`amountLamports` to the deposit address. The `sync` response contains actor-scoped lifecycle truth
+and the coordinator response timestamp; it does not expose an internal payout due timestamp. A
+refund receipt also carries the coordinator-authoritative accepted amount; use that value for
+pending refund accounting and use `sync` for final landing, cancellation, and fee-loss outcomes.
 
-## Security model
+For crash recovery before delegation, persist `policySnapshot` from the contract result and call
+`resumePreDelegation` with it, the `resumeSecret`, and the Recovery Code commitment. When resuming
+DKG, `onDelegateShareReady` is invoked before `DkgRound2` so the generated Alice share can be
+persisted. Resume fails closed if the coordinator acknowledges a different spending policy.
+
+## Private-transfer amount limits
+
+Use the public user-entry constants for inclusive preflight validation. Values are expressed in
+lamports, matching the `amountLamports` request field. The current V0 bounds are `1.5 SOL`
+(`1_500_000_000` lamports) minimum and `100 SOL` (`100_000_000_000` lamports) maximum.
+The SDK rejects non-safe integers and values outside these bounds before sending a coordinator
+request.
+
+```ts
+import { MAX_ENTRY_AMOUNT_LAMPORTS, MIN_ENTRY_AMOUNT_LAMPORTS } from "@invisible-labs/sdk/user";
+
+const isValidEntryAmount = (amountLamports: number) =>
+  Number.isSafeInteger(amountLamports) &&
+  amountLamports >= MIN_ENTRY_AMOUNT_LAMPORTS &&
+  amountLamports <= MAX_ENTRY_AMOUNT_LAMPORTS;
+```
+
+## Live and deferred surfaces
 
-The SDK establishes an encrypted Noise XX channel and verifies TDX attestation
-before sensitive protocol material is sent. Verification failures stop the
-session.
+Live today:
 
-Integrators remain responsible for:
+- `createSession` opens a live WebSocket, runs Noise XX, verifies TDX attestation, and returns an
+  attested `Session`.
+- `contractRequest`, `sync`, and `requestRefund` are the only normal-user command path over a
+  caller-owned attested session. `closeSession` ends the flow.
+- LP lifecycle helpers drive position open/recover, DKG, funding, refill, withdrawal, confirmation,
+  and listing.
+- Input validation throws typed `PolicyValidationError`; the closed `InvisibleError` taxonomy and
+  `normalizeError` are available to callers.
 
-- loading coordinator measurements from an approved release source;
-- protecting Recovery Codes and sync secrets;
-- persisting recovery material before asking a user to deposit;
-- using fresh payout destinations;
-- handling reconnects through sync instead of blindly repeating commands.
+Other target surfaces throw `NotImplementedError` until each is finalized. No command fakes success.
 
-Invisible is trust-minimized, not trustless. Attestation verifies an approved
-coordinator build; it does not prove that the code is bug-free. Privacy is not
-absolute and can be weakened by low pool depth, timing, amount correlation,
-destination reuse, and off-chain metadata.
+## Recovery material and storage
 
-Read the full
-[trust model and security boundaries](https://docs.invisible.exchange/docs/security/).
+The SDK does not persist recovery material automatically. Consumers that need restart or tab-close
+recovery must store the relevant values themselves:
+
+| Material                | Needed for                                      | Guidance                                                |
+| ----------------------- | ----------------------------------------------- | ------------------------------------------------------- |
+| `swapId` + `syncSecret` | Re-sync a private-transfer status view          | Persist before asking the user to deposit.              |
+| User Recovery Code      | Request an origin-bound private-transfer refund | Treat it like a seed phrase and persist it immediately. |
+| LP Position Code        | Recover and operate an LP position              | Keep it out of logs and treat it like a seed phrase.    |
+
+The web app persists private-transfer recovery material locally so users can resume flows. SDK
+consumers can choose `browserStorage`, `extensionStorage`, or their own encrypted storage layer.
+
+LP DKG requests are bounded. If a browser worker stops responding, the SDK terminates the local
+workers and attempts the signed position-scoped DKG abort command within a bounded cleanup window
+before returning the original failure. LP recovery sends the same cleanup command for an
+incomplete position, so a reload does not wait for the coordinator's session expiry.
+
+## Security model
+
+The SDK establishes an encrypted Noise XX channel and verifies TDX attestation before sensitive
+protocol material is sent. Verification failures stop the session. Integrators remain responsible
+for loading coordinator measurements from an approved release source, protecting Recovery Codes and
+sync secrets, persisting recovery material before deposit, using fresh payout destinations, and
+handling reconnects through `sync` instead of blindly repeating commands.
+
+Invisible is trust-minimized, not trustless. Attestation verifies an approved coordinator build; it
+does not prove that the code is bug-free. Privacy can be weakened by low pool depth, timing, amount
+correlation, destination reuse, and off-chain metadata.
 
 ## Devnet limitations
 
@@ -105,15 +184,52 @@ Read the full
 - Availability and privacy strength depend on current pool conditions.
 - Some documented target APIs are not yet available in the devnet beta.
 
-Use only APIs marked as live in the
-[current reference](https://docs.invisible.exchange/docs/sdk/reference/).
+Use only APIs marked as live in the [current reference](https://docs.invisible.exchange/docs/sdk/reference/).
+
+## Not in this SDK
+
+Protocol-fee admin payout is out of scope for the SDK. It lives behind a separate admin surface.
+
+## Packaging
+
+The package is bundled with tsup into a self-contained artifact. Workspace-internal packages and the
+FROST WASM are inlined into the published bundle, while published third-party packages remain
+external dependencies.
+
+```bash
+npm run build:private
+npm run verify:exports
+npm run verify:private-artifact
+```
+
+The public artifact is built separately with approved release inputs:
+
+```bash
+SDK_PRODUCTION_BINARY_HASH=<64-hex-binary-sha256> \
+AZURE_PROD_EXPECTED_BINARY_HASH=<same-64-hex-binary-sha256> \
+SDK_PRODUCTION_COORDINATOR_MRTD=<96-hex-mrtd> \
+SDK_PRODUCTION_RUNTIME_PROFILE=prod-devnet-simplified \
+npm run build:public
+npm run verify:exports
+npm run verify:public-build-marker
+npm run verify:public-artifact
+```
+
+The public production smoke consumes that already verified artifact. It requires
+`--prebuilt-sdk` plus an operator-approved release manifest whose exact file
+SHA-256 is supplied separately:
+
+```bash
+SDK_APPROVED_RELEASE_MANIFEST_PATH=<approved-release-manifest> \
+SDK_APPROVED_RELEASE_MANIFEST_SHA256=<sha256-of-manifest-bytes> \
+npm --workspace @invisible-labs/sdk run smoke:prod-attestation -- \
+  --host tee-azure.invisible.exchange --mrtd <96-hex-mrtd> \
+  --binary-hash <64-hex-binary-sha256> --target public \
+  --runtime-profile prod-devnet-simplified --prebuilt-sdk
+```
 
-## Documentation
+Do not pack the workspace directly. Use the private or public staged publish
+commands so the selected build target and artifact marker are checked.
 
-- [SDK overview](https://docs.invisible.exchange/docs/sdk/)
-- [Quickstart](https://docs.invisible.exchange/docs/sdk/quickstart/)
-- [Examples](https://docs.invisible.exchange/docs/sdk/examples/)
-- [API reference](https://docs.invisible.exchange/docs/sdk/reference/)
-- [Compatibility](https://docs.invisible.exchange/docs/sdk/compatibility/)
-- [Versioning](https://docs.invisible.exchange/docs/sdk/versioning/)
-- [V0 launch scope](https://docs.invisible.exchange/docs/v0-launch/)
+Private smoke runs may rebuild the private SDK. Public smoke must use
+`--prebuilt-sdk` so it cannot rebuild after the public artifact gates.

package/dist/.invisible-sdk-build-target.json

@@ -0,0 +1,7 @@
+{
+  "package": "@invisible-labs/sdk",
+  "target": "public",
+  "productionBinaryHash": "92237e1cc0d528a12288ff5a2d99eff38ab387080d31eb4146526daa6c973860",
+  "productionMrtd": "a2e61f1316e9e367e9c1f7a0adc98c48eb13875c399c85d286cee5ea2b05e57f2df9f61d903b0ae7ac5607d843dfffc1",
+  "productionRuntimeProfile": "prod-devnet-simplified"
+}

package/dist/{chunk-TQNNTV5F.js → chunk-4X5OCCQW.js}

@@ -6,12 +6,12 @@ var LP_DEFAULT_TARGET_SHARDS = 200;
 var LP_MAX_TARGET_SHARDS = 300;
 var LP_DEFAULT_REFILL_BATCH_SIZE = 50;
 var LP_MAX_REFILL_BATCH_SIZE = 50;
-var PRODUCT_MIN_ENTRY_LAMPORTS = 4e8;
+var PRODUCT_MIN_ENTRY_LAMPORTS = 15e8;
 var PRODUCT_MAX_ENTRY_LAMPORTS = 1e11;
 function isValidLpPositionId(lpPositionId) {
   return lpPositionId.length >= LP_POSITION_ID_MIN_LENGTH && lpPositionId.length <= LP_POSITION_ID_MAX_LENGTH && LP_POSITION_ID_PATTERN.test(lpPositionId);
 }
 
 export { LP_DEFAULT_REFILL_BATCH_SIZE, LP_DEFAULT_TARGET_SHARDS, LP_MAX_REFILL_BATCH_SIZE, LP_MAX_TARGET_SHARDS, PRODUCT_MAX_ENTRY_LAMPORTS, PRODUCT_MIN_ENTRY_LAMPORTS, isValidLpPositionId };
-//# sourceMappingURL=chunk-TQNNTV5F.js.map
-//# sourceMappingURL=chunk-TQNNTV5F.js.map
+//# sourceMappingURL=chunk-4X5OCCQW.js.map
+//# sourceMappingURL=chunk-4X5OCCQW.js.map

package/dist/{chunk-TQNNTV5F.js.map → chunk-4X5OCCQW.js.map}

@@ -1 +1 @@
-{"version":3,"sources":["../../shared/src/index.ts"],"names":[],"mappings":";AAgBO,IAAM,yBAAA,GAA4B,CAAA;AAClC,IAAM,yBAAA,GAA4B,EAAA;AAClC,IAAM,sBAAA,GAAyB,kBAAA;AAC/B,IAAM,wBAAA,GAA2B;AACjC,IAAM,oBAAA,GAAuB;AAC7B,IAAM,4BAAA,GAA+B;AACrC,IAAM,wBAAA,GAA2B;AAKjC,IAAM,0BAAA,GAA6B;AACnC,IAAM,0BAAA,GAA6B;AAGnC,SAAS,oBAAoB,YAAA,EAA+B;AACjE,EAAA,OACE,YAAA,CAAa,UAAU,yBAAA,IACvB,YAAA,CAAa,UAAU,yBAAA,IACvB,sBAAA,CAAuB,KAAK,YAAY,CAAA;AAE5C","file":"chunk-TQNNTV5F.js","sourcesContent":["/**\n * Shared workspace entrypoint.\n *\n * Keep exports here pure and reusable across workspaces. Do not put React,\n * DOM-only, libp2p runtime state, or feature-specific glue in this package.\n */\nexport function sleep(ms: number): Promise<void> {\n  if (ms <= 0) {\n    return Promise.resolve();\n  }\n\n  return new Promise((resolve) => {\n    setTimeout(resolve, ms);\n  });\n}\n\nexport const LP_POSITION_ID_MIN_LENGTH = 3;\nexport const LP_POSITION_ID_MAX_LENGTH = 96;\nexport const LP_POSITION_ID_PATTERN = /^[A-Za-z0-9_-]+$/;\nexport const LP_DEFAULT_TARGET_SHARDS = 200;\nexport const LP_MAX_TARGET_SHARDS = 300;\nexport const LP_DEFAULT_REFILL_BATCH_SIZE = 50;\nexport const LP_MAX_REFILL_BATCH_SIZE = 50;\n\n// Temporary TypeScript mirrors of the Rust TEE entry limits, plus the distinct\n// mainnet UI default. Keep them guarded by `npm run product-limits:check` until\n// cross-language generated product constants exist.\nexport const PRODUCT_MIN_ENTRY_LAMPORTS = 400_000_000;\nexport const PRODUCT_MAX_ENTRY_LAMPORTS = 100_000_000_000;\nexport const PRODUCT_DEFAULT_MAINNET_ENTRY_LAMPORTS = 3_000_000_000;\n\nexport function isValidLpPositionId(lpPositionId: string): boolean {\n  return (\n    lpPositionId.length >= LP_POSITION_ID_MIN_LENGTH &&\n    lpPositionId.length <= LP_POSITION_ID_MAX_LENGTH &&\n    LP_POSITION_ID_PATTERN.test(lpPositionId)\n  );\n}\n"]}
+{"version":3,"sources":["../../shared/src/index.ts"],"names":[],"mappings":";AAgBO,IAAM,yBAAA,GAA4B,CAAA;AAClC,IAAM,yBAAA,GAA4B,EAAA;AAClC,IAAM,sBAAA,GAAyB,kBAAA;AAC/B,IAAM,wBAAA,GAA2B;AACjC,IAAM,oBAAA,GAAuB;AAC7B,IAAM,4BAAA,GAA+B;AACrC,IAAM,wBAAA,GAA2B;AAKjC,IAAM,0BAAA,GAA6B;AACnC,IAAM,0BAAA,GAA6B;AAGnC,SAAS,oBAAoB,YAAA,EAA+B;AACjE,EAAA,OACE,YAAA,CAAa,UAAU,yBAAA,IACvB,YAAA,CAAa,UAAU,yBAAA,IACvB,sBAAA,CAAuB,KAAK,YAAY,CAAA;AAE5C","file":"chunk-4X5OCCQW.js","sourcesContent":["/**\n * Shared workspace entrypoint.\n *\n * Keep exports here pure and reusable across workspaces. Do not put React,\n * DOM-only, libp2p runtime state, or feature-specific glue in this package.\n */\nexport function sleep(ms: number): Promise<void> {\n  if (ms <= 0) {\n    return Promise.resolve();\n  }\n\n  return new Promise((resolve) => {\n    setTimeout(resolve, ms);\n  });\n}\n\nexport const LP_POSITION_ID_MIN_LENGTH = 3;\nexport const LP_POSITION_ID_MAX_LENGTH = 96;\nexport const LP_POSITION_ID_PATTERN = /^[A-Za-z0-9_-]+$/;\nexport const LP_DEFAULT_TARGET_SHARDS = 200;\nexport const LP_MAX_TARGET_SHARDS = 300;\nexport const LP_DEFAULT_REFILL_BATCH_SIZE = 50;\nexport const LP_MAX_REFILL_BATCH_SIZE = 50;\n\n// Temporary TypeScript mirrors of the Rust TEE entry limits, plus the distinct\n// mainnet UI default. Keep them guarded by `npm run product-limits:check` until\n// cross-language generated product constants exist.\nexport const PRODUCT_MIN_ENTRY_LAMPORTS = 1_500_000_000;\nexport const PRODUCT_MAX_ENTRY_LAMPORTS = 100_000_000_000;\nexport const PRODUCT_DEFAULT_MAINNET_ENTRY_LAMPORTS = 1_500_000_000;\n\nexport function isValidLpPositionId(lpPositionId: string): boolean {\n  return (\n    lpPositionId.length >= LP_POSITION_ID_MIN_LENGTH &&\n    lpPositionId.length <= LP_POSITION_ID_MAX_LENGTH &&\n    LP_POSITION_ID_PATTERN.test(lpPositionId)\n  );\n}\n"]}

package/dist/{chunk-7DSVN3MV.js → chunk-5NNEO7IK.js}

@@ -1,6 +1,6 @@
-import { failSessionClosed, createSessionHandle, getSessionState, closeSessionState } from './chunk-JRMKCE3S.js';
-import { verifyAttestation, assertAttestResponse } from './chunk-NCY4FCYU.js';
-import { TransportError, AttestationError } from './chunk-OHIM2YWU.js';
+import { failSessionClosed, createSessionHandle, getSessionState, closeSessionState } from './chunk-V5HXJRBW.js';
+import { verifyAttestation, assertAttestResponse } from './chunk-DIA6U2CV.js';
+import { TransportError, AttestationError } from './chunk-GHBQF3A7.js';
 import { generateKeyPair, sharedKey } from '@stablelib/x25519';
 import { ChaCha20Poly1305 } from '@stablelib/chacha20poly1305';
 import { hash, SHA256 } from '@stablelib/sha256';
@@ -398,6 +398,7 @@ function toAttestationPolicy(endpoint) {
     // ignore the MRTD pin inside the verifier.
     expectedMrtd: pin.mrtd,
     ...pin.binaryHash ? { expectedBinaryHash: pin.binaryHash } : {},
+    ...pin.runtimeProfile ? { expectedRuntimeProfile: pin.runtimeProfile } : {},
     allowMissingDcapCollateral: pin.allowMissingDcapCollateral === true,
     allowLocalAttestation
   };
@@ -694,6 +695,7 @@ async function establishAttestedChannel(params) {
     mrtd: channel.attestation.mrtd,
     mode: channel.attestation.mode,
     binaryHash: channel.attestation.binaryHash,
+    runtimeProfile: channel.attestation.runtimeProfile,
     pubkeyHex: channel.attestation.pubkeyHex,
     localAttestation: channel.attestation.localAttestation,
     rtmr0: channel.attestation.rtmr0,
@@ -705,33 +707,6 @@ async function establishAttestedChannel(params) {
   void toAttestationPolicy(endpoint);
   return { channel, handshake, attestation };
 }
-async function performNoiseHandshake(transport, endpoint, nonce = crypto.getRandomValues(new Uint8Array(32))) {
-  const established = await establishAttestedChannel({ transport, endpoint, nonce });
-  return established.handshake;
-}
-function performAttestation(_transport, handshake) {
-  const channel = handshake.channel;
-  if (!channel) {
-    return Promise.reject(
-      new TransportError(
-        "NOISE_HANDSHAKE_FAILED",
-        "performAttestation requires a handshake result produced by performNoiseHandshake"
-      )
-    );
-  }
-  return Promise.resolve({
-    mrtd: channel.attestation.mrtd,
-    mode: channel.attestation.mode,
-    binaryHash: channel.attestation.binaryHash,
-    pubkeyHex: channel.attestation.pubkeyHex,
-    localAttestation: channel.attestation.localAttestation,
-    rtmr0: channel.attestation.rtmr0,
-    rtmr1: channel.attestation.rtmr1,
-    rtmr2: channel.attestation.rtmr2,
-    rtmr3: channel.attestation.rtmr3,
-    verifiedAtMs: Date.now()
-  });
-}
 
 // src/schemas/payoutPolicy.schema.json
 var payoutPolicy_schema_default = {
@@ -872,6 +847,10 @@ var coordinatorPoolConfig_schema_default = {
           pattern: "^[0-9a-fA-F]{64}$",
           description: "Optional SHA-256 hash of the approved coordinator binary; required for production Azure attestation."
         },
+        runtimeProfile: {
+          enum: ["prod-hardened", "prod-devnet-simplified"],
+          description: "Optional compile-time coordinator runtime profile; production simplified deployments must pin it."
+        },
         intelRootFingerprint: {
           type: "string",
           description: "Hex SHA-256 of the Intel root cert."
@@ -1023,6 +1002,7 @@ async function reattest(state, endpoint, timeoutMs = DEFAULT_REATTEST_TIMEOUT_MS
     mrtd: metadata.mrtd,
     mode: metadata.mode,
     binaryHash: metadata.binaryHash,
+    runtimeProfile: metadata.runtimeProfile,
     pubkeyHex: metadata.pubkeyHex,
     localAttestation: metadata.localAttestation,
     rtmr0: metadata.rtmr0,
@@ -1052,7 +1032,7 @@ function toHex(b) {
 
 // src/session/createSession.ts
 var REATTEST_EVERY_MS = 9e5;
-async function createSession(options) {
+async function createSessionInternal(options) {
   const { coordinator } = options;
   if (!validateCoordinatorPoolConfigShape(coordinator)) {
     throw new Error(
@@ -1063,11 +1043,15 @@ async function createSession(options) {
   assertExpectedHostname(endpoint);
   const timeoutMs = coordinator.noiseTransportTimeoutMs;
   const transport = options.transport ?? noiseWebSocketTransport({ wsUrl: endpoint.wsUrl, connectTimeoutMs: timeoutMs });
-  await transport.connect();
+  await transport.connect(options.signal);
   const nonce = crypto.getRandomValues(new Uint8Array(32));
   let established;
   try {
-    established = await establishAttestedChannel({ transport, endpoint, nonce, timeoutMs });
+    established = await abortableSessionEstablishment(
+      establishAttestedChannel({ transport, endpoint, nonce, timeoutMs }),
+      transport,
+      options.signal
+    );
   } catch (err) {
     transport.close();
     throw err;
@@ -1092,6 +1076,27 @@ async function createSession(options) {
   scheduleReattest(state, endpoint);
   return createSessionHandle(state);
 }
+function abortableSessionEstablishment(establishment, transport, signal) {
+  if (signal === void 0) return establishment;
+  if (signal.aborted) {
+    transport.close();
+    return Promise.reject(createSessionAbortError());
+  }
+  return new Promise((resolve, reject) => {
+    const onAbort = () => {
+      transport.close();
+      reject(createSessionAbortError());
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    void establishment.then(resolve, reject).finally(() => {
+      signal.removeEventListener("abort", onAbort);
+    });
+  });
+}
+function createSessionAbortError() {
+  return new TransportError("CONNECTION_LOST", "session establishment aborted");
+}
+var createSession = createSessionInternal;
 function assertExpectedHostname(endpoint) {
   let hostname;
   try {
@@ -1140,6 +1145,6 @@ async function runReattest(state, endpoint) {
   }
 }
 
-export { closeSession, createExponentialBackoff, createSession, createStateController, formatAjvErrors, noiseWebSocketTransport, performAttestation, performNoiseHandshake, reattestSerialized, validatePayoutPolicyShape };
-//# sourceMappingURL=chunk-7DSVN3MV.js.map
-//# sourceMappingURL=chunk-7DSVN3MV.js.map
+export { closeSession, createExponentialBackoff, createSession, createSessionInternal, createStateController, formatAjvErrors, isLoopbackUrl, noiseWebSocketTransport, reattestSerialized, validatePayoutPolicyShape };
+//# sourceMappingURL=chunk-5NNEO7IK.js.map
+//# sourceMappingURL=chunk-5NNEO7IK.js.map