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

package/dist/index.d.ts

@@ -1,10 +1,8 @@
 import { S as Session } from './session-DFuy54C-.js';
 export { i as isAttested } from './session-DFuy54C-.js';
-export { A as AttestationError, a as AttestationErrorCode, b as CommandError, c as CommandErrorCode, d as CommandErrorOptions, e as CoordinatorWireErrorCode, C as CreateSessionOptions, I as InvalidDepositAmountError, f as InvisibleError, g as InvisibleErrorCode, h as InvisibleErrorOptions, L as LpLifecycleError, i as LpLifecycleErrorCode, N as NotImplementedError, j as NotImplementedErrorCode, P as PolicyValidationError, k as PolicyValidationErrorCode, R as RoutingError, l as RoutingErrorCode, S as StorageError, m as StorageErrorCode, T as TransportError, n as TransportErrorCode, W as WalletError, o as WalletErrorCode, p as closeSession, q as createSession, r as isInvisibleError, s as normalizeError } from './createSession-D3ym-Ira.js';
+export { A as AttestationError, a as AttestationErrorCode, C as CommandError, b as CommandErrorCode, c as CommandErrorOptions, d as CoordinatorWireErrorCode, I as InvalidDepositAmountError, e as InvisibleError, f as InvisibleErrorCode, g as InvisibleErrorOptions, L as LpLifecycleError, h as LpLifecycleErrorCode, i as LpPositionView, N as NotImplementedError, j as NotImplementedErrorCode, k as PayoutDestination, P as PayoutPolicy, l as PolicyValidationError, m as PolicyValidationErrorCode, R as RoutingError, n as RoutingErrorCode, S as StorageEnvelope, o as StorageError, p as StorageErrorCode, T as TransportError, q as TransportErrorCode, W as WalletError, r as WalletErrorCode, s as isInvisibleError, t as normalizeError } from './types.generated-DJBTjLpP.js';
 import { T as Transport, N as NoiseWebSocketTransportOptions, U as Unsubscribe } from './types-ZhV7TIQY.js';
 export { C as ConnectionState, W as WebSocketFactory, a as WebSocketLike } from './types-ZhV7TIQY.js';
-import { C as CoordinatorEndpoint, b as CoordinatorReleasePin } from './types.generated-CHGSbmLp.js';
-export { A as AzureMaaPin, a as CoordinatorPoolConfig, L as LpPositionView, c as PayoutDestination, P as PayoutPolicy, S as StorageEnvelope } from './types.generated-CHGSbmLp.js';
 
 /**
  * The API surface version this build implements. Bumped only on a breaking
@@ -134,220 +132,48 @@ declare function inMemoryTransport(options?: InMemoryTransportOptions): InMemory
 declare function noiseWebSocketTransport(options: NoiseWebSocketTransportOptions): Transport;
 
 /**
- * TDX DCAP attestation verifier (SDK port of
- * `web/src/lib/coordinator/tdx-attestation.ts`).
+ * `createSession` - the single entrypoint that opens an attested session.
  *
- * Verifies a TDX DCAP quote on three paths, using Web Crypto (`crypto.subtle`,
- * a Node 22 / browser global) and `@peculiar/x509`:
+ * It validates the endpoint pool, opens the transport, runs the Noise XX
+ * handshake + TDX attestation, and returns an opaque {@link Session} that has
+ * already passed attestation (`attested === true`). It resolves only once
+ * attestation succeeds; any transport or attestation failure rejects with a
+ * typed {@link TransportError} / {@link AttestationError}.
  *
- *   - GCP  (spec section 5.1): cert chain to the pinned Intel SGX Root CA, TCB
- *     validity, freshness nonce == REPORT_DATA[0:32], Noise binding ==
- *     REPORT_DATA[32:64], debug bit clear, MRTD pin.
- *   - Azure (spec section 5.2): MAA JWT issuer / JWKS / policy-hash / compliance
- *     / debug, MAA<->DCAP REPORTDATA binding, hcl_keys hash binding, HCL AK pub
- *     extraction, raw DCAP measurement binding, TPM AK quote signature, TPM
- *     qualifying data binding.
- *   - Local (loopback dev fallback): checks nonce and Noise pubkey consistency
- *     only; no hardware attestation.
- *
- * Throws the SDK {@link AttestationError} (from `../core/errors.js`) with a
- * closed `code` on any failure. Callers fail-closed: tear down the Noise
- * transport rather than surface an unverified channel.
- *
- * Never log secrets, nonces, or raw decrypted payloads (spec section 9).
+ * A re-attestation timer re-runs verification over the live channel every
+ * {@link REATTEST_EVERY_MS}; on failure it marks the session unattested and
+ * notifies any registered policy-violation handlers. The transport is
+ * injectable for tests.
+ */
+
+/** Close a session created by {@link createSession}. */
+declare function closeSession(session: Session): void;
+
+interface PublicCreateSessionOptions {
+    readonly coordinatorUrl: string;
+    readonly storage?: unknown;
+    readonly wallet?: unknown;
+}
+/**
+ * Open a production-only public SDK session.
  *
- * @module JW-145 / JW-431
+ * The caller supplies only the route and public adapters. The Azure
+ * production release policy is embedded by the selected SDK build.
  */
-type AttestationMode = "dev" | "prod";
-type AzureMaaPolicy = {
-    /** Expected MAA token issuer for the approved Azure Attestation provider. */
-    expectedIssuer: string;
-    /** Expected JWKS endpoint for that provider. Token headers must not choose it. */
-    expectedJwksUrl: string;
-    /** Expected Azure Attestation evaluation policy hash from the signed token. */
-    expectedPolicyHash: string;
-};
-type AttestationPolicy = {
-    /**
-     * Expected MRTD for the published production coordinator build.
-     * Dev mode ignores this pin entirely.
-     */
-    expectedMrtd?: string;
-    /**
-     * SHA-256 hash of the approved coordinator binary. Azure production
-     * attestation requires this pin because binary_hash is otherwise only
-     * response metadata, even though the TPM quote binds it cryptographically.
-     */
-    expectedBinaryHash?: string;
-    /**
-     * Runtime mode the client expects for this coordinator route. Production
-     * builds set this to "prod" so a prod hostname cannot silently accept an
-     * unpinned dev coordinator after DNS or load-balancer misrouting.
-     */
-    requiredMode?: AttestationMode;
-    /**
-     * Release tooling only: verify a prod quote before the new MRTD has been
-     * published. Runtime policy must leave this unset so prod stays fail-closed
-     * when the pin is missing.
-     */
-    allowUnpinnedProdMrtdForRelease?: boolean;
-    /**
-     * SHA-256 fingerprint (lowercase hex) of the DER-encoded Intel SGX Root CA.
-     * Defaults to {@link INTEL_SGX_ROOT_CA_FINGERPRINT_SHA256}. Override only in tests.
-     */
-    intelRootFingerprint?: string;
-    /**
-     * Temporary non-prod rollout escape hatch for legacy coordinators that have
-     * not rolled out `dcap_collateral`. When collateral is present, it is always
-     * verified. Production mode never honors this flag.
-     */
-    allowMissingDcapCollateral?: boolean;
-    /**
-     * Development-only escape hatch for a local coordinator running on a non-TDX
-     * machine. The transport only honors this for loopback coordinator URLs.
-     */
-    allowLocalAttestation?: boolean;
-    /**
-     * Azure-specific trust policy. Required for platform="azure-tdx-dcap" because
-     * MAA providers and policies are customer-configurable Azure resources.
-     */
-    azureMaa?: AzureMaaPolicy;
-};
-type SignedDcapJson = {
-    /**
-     * JSON string returned by Intel PCS. May be either the inner body
-     * (`tcbInfo` / `enclaveIdentity`) or the full PCS wrapper.
-     */
-    body: string;
-    /** Hex signature over the exact signed body bytes. */
-    signature: string;
-    /** PEM chain whose first certificate verifies `signature`, ending at Intel root. */
-    issuerChainPem: string;
-};
-type DcapCollateral = {
-    /** PEM X.509 CRL for the PCK certificate issuer. */
-    pckCrlPem: string;
-    /** PEM chain for the PCK CRL issuer, ending at Intel root. */
-    pckCrlIssuerChainPem: string;
-    /** PEM X.509 CRL issued by Intel root, covering collateral signing certs. */
-    rootCaCrlPem: string;
-    /** Signed Intel TDX TCB Info V3. */
-    tcbInfo: SignedDcapJson;
-    /** Signed Intel TD QE Identity V2. */
-    qeIdentity: SignedDcapJson;
-};
-type AttestedMetadata = {
-    mode: AttestationMode;
-    binaryHash: string;
-    mrtd: string;
-    rtmr0: string;
-    rtmr1: string;
-    rtmr2: string;
-    rtmr3: string;
-    pubkeyHex: string;
-    localAttestation: boolean;
-};
-type AttestResponse = {
-    quote: string;
-    /**
-     * Nonce echoed back by the coordinator. Informational only: freshness is
-     * enforced cryptographically via REPORT_DATA[0:32] inside the TDX quote, not
-     * by trusting this JSON field.
-     */
-    nonce: string;
-    pubkey: string;
-    binary_hash: string;
-    mode: AttestationMode;
-    /**
-     * Platform identifier set by the coordinator. Absent on GCP (tdx-dcap).
-     * Azure returns "azure-tdx-dcap".
-     */
-    platform?: string;
-    /**
-     * Azure only: MAA JWT from /attest/TdxVm, RS256-signed by MAA. Contains
-     * tdx_mrtd, tdx_td_attributes_debug, and x-ms-compliance-status.
-     */
-    maa_token?: string;
-    /**
-     * Azure only: TPM PCR quote packed as
-     * [4-byte msg_len LE][TPM2B_ATTEST][TPMT_SIGNATURE].
-     * qualifying_data = SHA-256(nonce || noise_pubkey || binary_hash). Base64-encoded.
-     */
-    tpm_quote?: string;
-    /**
-     * Azure only: raw bytes (base64) of the JSON key-blob from HCL report NV
-     * 0x1400001 [1056:]. SHA-256(hcl_keys_json_bytes) == DCAP REPORTDATA[0:32].
-     * Contains the AK public key as kid="HCLAkPub".
-     */
-    hcl_keys_json?: string;
-    /**
-     * Intel DCAP verification collateral. When present, the verifier evaluates
-     * PCK revocation, TCB Info, and TD QE Identity. Policies can require it.
-     */
-    dcap_collateral?: DcapCollateral;
-    local_attestation?: boolean;
-};
+declare function createSession(options: PublicCreateSessionOptions): Promise<Session>;
+
 /**
- * Assert that an unknown JSON value has the shape of {@link AttestResponse}.
- * Throws {@link AttestationError} ("NOT_ATTESTED") on any missing or wrong-typed
- * field. Replaces an unsafe cast so missing fields produce a typed error rather
- * than silently reaching downstream checks as `undefined`.
+ * Session guards used by mutating commands.
  */
-declare function assertAttestResponse(value: unknown): asserts value is AttestResponse;
-declare function verifyAttestation(params: {
-    response: AttestResponse;
-    expectedNonce: Uint8Array;
-    expectedNoiseStaticPub: Uint8Array;
-    policy: AttestationPolicy;
-    timeoutMs?: number;
-}): Promise<AttestedMetadata>;
 
 /**
- * Secure channel: Noise XX handshake + TDX attestation over a raw transport.
- *
- * Free functions, no class (SDK conformance). Given an open {@link Transport}
- * and a {@link CoordinatorEndpoint}, {@link establishSecureChannel} drives:
- *
- *   1. the Noise XX handshake (initiator role) over the raw byte channel:
- *        -> msg1 (e)            send raw
- *        <- msg2 (e, ee, s, es) read raw, reveals the responder static pubkey
- *        -> msg3 (s, se)        send raw, yields the split NoiseTransport
- *   2. the attestation exchange over the freshly-split (but not-yet-promoted)
- *      Noise transport:
- *        -> encrypt(encodeAttestationRequest(nonceHex))
- *        <- decodeAttestationResponse(decrypt(frame)) -> verifyAttestation
- *
- * On success the pending Noise transport is promoted to the live cipher and an
- * attested channel handle is returned: `send`/`onMessage` transparently
- * Noise-encrypt/decrypt application frames over the raw transport.
- *
- * The release pin (mrtd, intelRootFingerprint, azureMaa) and the endpoint's
- * requiredMode map to the verifier's {@link AttestationPolicy}. The loopback
- * local-attestation fallback (ADR-0037) is only enabled when the endpoint host
- * is a loopback address - it must never be honored for a remote coordinator.
- *
- * Never log secrets, nonces, shares, or decrypted payloads (spec section 9).
+ * Assert the session has passed attestation. Every mutating actor command calls
+ * this before touching the wire, so an unattested session can never sign or
+ * send sensitive material.
  *
- * @module JW-428
+ * @throws AttestationError `NOT_ATTESTED` when the session is not attested.
  */
-
-/** An established, attested Noise channel over a raw transport. */
-interface SecureChannel {
-    /** Verified attestation metadata for the coordinator this channel reached. */
-    readonly attestation: AttestedMetadata;
-    /** The coordinator's Noise static public key, pinned for this channel. */
-    readonly remoteStaticPublicKey: Uint8Array;
-    /** Request re-attestation without consuming application frames as responses. */
-    requestAttestation(nonceHex: string, timeoutMs: number): Promise<AttestResponse>;
-    /** Encrypt and send one application frame over the raw transport. */
-    send(plaintext: Uint8Array): void;
-    /** Subscribe to decrypted inbound application frames. */
-    onMessage(handler: (plaintext: Uint8Array) => void): Unsubscribe;
-    /** Subscribe to fatal channel failures such as Noise decrypt desync. */
-    onFatal(handler: (error: Error) => void): Unsubscribe;
-    /** Tear down the channel: detach listeners and stop accepting frames. */
-    close(): void;
-}
+declare function assertAttested(session: Session): void;
 
 /**
  * Session-establishment seams layered on top of an open {@link Transport}.
@@ -365,17 +191,6 @@ interface SecureChannel {
  * one step should use {@link establishAttestedChannel}.
  */
 
-/** Result of a completed Noise XX handshake. */
-interface NoiseHandshakeResult {
-    /** The coordinator's Noise static public key, pinned for this session. */
-    readonly noiseStaticPublicKey: Uint8Array;
-    /**
-     * The attested secure channel produced by this handshake. Carried so a
-     * subsequent {@link performAttestation} can read attestation evidence without
-     * re-running the exchange. Internal: not part of the structural contract.
-     */
-    readonly channel: SecureChannel;
-}
 /** Result of a completed TDX attestation. */
 interface AttestationResult {
     /** The verified release MRTD. */
@@ -384,6 +199,8 @@ interface AttestationResult {
     readonly mode: "prod" | "dev";
     /** Coordinator binary hash reported by the verified attestation response. */
     readonly binaryHash: string;
+    /** Compile-time runtime profile carried by the attested coordinator artifact. */
+    readonly runtimeProfile?: "prod-hardened" | "prod-devnet-simplified";
     /** Noise static public key bound into the attestation quote. */
     readonly pubkeyHex: string;
     /** True only for explicit loopback local development attestation. */
@@ -395,76 +212,38 @@ interface AttestationResult {
     /** When verification completed (epoch ms), stamped by the caller. */
     readonly verifiedAtMs: number;
 }
-/**
- * Run the Noise XX handshake over an open transport and pin the coordinator's
- * static key. Drives a full attested-channel establishment (attestation is
- * bound to the same Noise cipher) and returns the handshake half; read the
- * attestation half from {@link performAttestation} with the returned result.
- *
- * @throws TransportError if the channel fails or the handshake is malformed.
- * @throws AttestationError if attestation verification fails.
- */
-declare function performNoiseHandshake(transport: Transport, endpoint: CoordinatorEndpoint, nonce?: Uint8Array): Promise<NoiseHandshakeResult>;
-/**
- * Verify the coordinator's TDX attestation, bound to the handshake's Noise
- * static key. Reads the evidence captured by {@link performNoiseHandshake}.
- *
- * @throws TransportError if the handshake result carries no channel.
- */
-declare function performAttestation(_transport: Transport, handshake: NoiseHandshakeResult): Promise<AttestationResult>;
-
-/**
- * Session guards used by mutating commands.
- */
 
-/**
- * Assert the session has passed attestation. Every mutating actor command calls
- * this before touching the wire, so an unattested session can never sign or
- * send sensitive material.
- *
- * @throws AttestationError `NOT_ATTESTED` when the session is not attested.
- */
-declare function assertAttested(session: Session): void;
-
-/**
- * `attestation` - read controls and verification triggers (spec section 4.1).
- *
- * Grouped as a small object of free functions over the opaque `Session`. The
- * read accessors (`current`, `policy`) report the last verified result and the
- * active pin; `assertValid` re-runs attestation over the live channel and
- * `onPolicyViolation` subscribes to out-of-band re-attestation failures.
- */
+interface PublicProductionReleasePolicy {
+    readonly expectedMrtd: string;
+    readonly expectedBinaryHash: string;
+    readonly expectedRuntimeProfile: "prod-hardened" | "prod-devnet-simplified";
+}
 
+interface PublicAttestationPolicy {
+    readonly expectedMrtd: string;
+    readonly expectedBinaryHash?: string;
+    readonly expectedRuntimeProfile?: "prod-hardened" | "prod-devnet-simplified";
+    readonly intelRootFingerprint?: string;
+    readonly azureMaa?: {
+        readonly expectedIssuer: string;
+        readonly expectedJwksUrl: string;
+        readonly expectedPolicyHash: string;
+    };
+}
+/** Public attestation read controls. Policy construction remains internal. */
 declare const attestation: {
-    /**
-     * Force-verify the current session against the active policy by re-running
-     * attestation over the live channel. Updates the stored result on success.
-     *
-     * @throws AttestationError if verification fails.
-     * @throws TransportError if the session has no live attested channel.
-     */
+    productionPolicy(): PublicProductionReleasePolicy;
     assertValid(session: Session): Promise<AttestationResult>;
-    /** The last verified attestation result, or `null` before first attestation. */
     current(session: Session): AttestationResult | null;
-    /** The release pin the active leader endpoint is verified against. Read-only. */
-    policy(session: Session): CoordinatorReleasePin;
-    /**
-     * Subscribe to out-of-band attestation failures (e.g. during periodic
-     * re-attestation). The handler fires with the verification error; returns an
-     * unsubscribe function.
-     */
+    policy(session: Session): PublicAttestationPolicy;
     onPolicyViolation(session: Session, handler: (error: Error) => void): Unsubscribe;
 };
 
-/**
- * `coordinator` - endpoint pool inspection and failover (spec section 4.2).
- *
- * `endpoints` is a read accessor that works today. Leader discovery, version
- * reporting, and failover depend on the coordinator network surface and are
- * deferred (marked 🟡 V0-target in the spec).
- */
-
-/** Coordinator-reported version and role snapshot. */
+interface PublicCoordinatorEndpoint {
+    readonly coordinatorUrl: string;
+    readonly roleHint?: "leader" | "watcher";
+    readonly weight?: number;
+}
 interface CoordinatorVersion {
     readonly mode: "prod" | "dev";
     readonly protocolVersion: string;
@@ -473,27 +252,10 @@ interface CoordinatorVersion {
     readonly leaderEpoch: number;
 }
 declare const coordinator: {
-    /** All configured endpoints, in the order supplied. Read-only. */
-    endpoints(session: Session): readonly CoordinatorEndpoint[];
-    /**
-     * The endpoint currently accepting mutating commands.
-     *
-     * @throws NotImplementedError - deferred (coordinator-pending).
-     */
-    currentLeader(_session: Session): Promise<CoordinatorEndpoint | null>;
-    /**
-     * The coordinator-reported version snapshot.
-     *
-     * @throws NotImplementedError - deferred (coordinator-pending).
-     */
+    endpoints(session: Session): readonly PublicCoordinatorEndpoint[];
+    currentLeader(_session: Session): Promise<PublicCoordinatorEndpoint | null>;
     version(_session: Session): Promise<CoordinatorVersion>;
-    /**
-     * Tear down the active session and reconnect through the next healthy
-     * endpoint, forcing a fresh attestation.
-     *
-     * @throws NotImplementedError - deferred (coordinator-pending).
-     */
     forceFailover(_session: Session): Promise<void>;
 };
 
-export { type ApiVersion, type AttestResponse, type AttestationMode, type AttestationPolicy, type AttestationResult, type AzureMaaPolicy, type Brand, CoordinatorEndpoint, CoordinatorReleasePin, type CoordinatorVersion, type ExponentialBackoff, type ExponentialBackoffOptions, type Hex, type Lamports, type NoiseHandshakeResult, NoiseWebSocketTransportOptions, type PublicKey, type RequestId, Session, Transport, Unsubscribe, apiVersion, assertAttestResponse, assertAttested, attestation, coordinator, createExponentialBackoff, hex, inMemoryTransport, lamports, noiseWebSocketTransport, performAttestation, performNoiseHandshake, publicKey, requestId, verifyAttestation };
+export { type ApiVersion, type AttestationResult, type Brand, type CoordinatorVersion, type PublicCreateSessionOptions as CreateSessionOptions, type ExponentialBackoff, type ExponentialBackoffOptions, type Hex, type Lamports, NoiseWebSocketTransportOptions, type PublicAttestationPolicy, type PublicCoordinatorEndpoint, type PublicKey, type RequestId, Session, Transport, Unsubscribe, apiVersion, assertAttested, attestation, closeSession, coordinator, createExponentialBackoff, createSession, hex, inMemoryTransport, lamports, noiseWebSocketTransport, publicKey, requestId };

package/dist/index.js

@@ -1,10 +1,11 @@
-import { createStateController, reattestSerialized } from './chunk-7DSVN3MV.js';
-export { closeSession, createExponentialBackoff, createSession, noiseWebSocketTransport, performAttestation, performNoiseHandshake } from './chunk-7DSVN3MV.js';
-export { assertAttested, hex, lamports, publicKey, requestId } from './chunk-SZAYO2L5.js';
-import { getSessionState, failSessionClosed } from './chunk-JRMKCE3S.js';
-export { assertAttestResponse, verifyAttestation } from './chunk-NCY4FCYU.js';
-import { TransportError, NotImplementedError } from './chunk-OHIM2YWU.js';
-export { AttestationError, CommandError, InvalidDepositAmountError, InvisibleError, LpLifecycleError, NotImplementedError, PolicyValidationError, RoutingError, StorageError, TransportError, WalletError, isInvisibleError, normalizeError } from './chunk-OHIM2YWU.js';
+import { createStateController, createSessionInternal, isLoopbackUrl, reattestSerialized } from './chunk-5NNEO7IK.js';
+export { closeSession, createExponentialBackoff, noiseWebSocketTransport } from './chunk-5NNEO7IK.js';
+export { assertAttested, hex, lamports, publicKey, requestId } from './chunk-NHEHCUS5.js';
+import { getSessionState, failSessionClosed } from './chunk-V5HXJRBW.js';
+import { createAzureProductionEndpoint, APPROVED_PRODUCTION_RUNTIME_PROFILE } from './chunk-BRDLLGCZ.js';
+import './chunk-DIA6U2CV.js';
+import { TransportError, NotImplementedError } from './chunk-GHBQF3A7.js';
+export { AttestationError, CommandError, InvalidDepositAmountError, InvisibleError, LpLifecycleError, NotImplementedError, PolicyValidationError, RoutingError, StorageError, TransportError, WalletError, isInvisibleError, normalizeError } from './chunk-GHBQF3A7.js';
 import './chunk-VR6T6OJS.js';
 
 // src/core/version.ts
@@ -51,15 +52,76 @@ function inMemoryTransport(options = {}) {
   };
 }
 
-// src/attestation/index.ts
+// src/presets/productionBinaryHash.ts
+var APPROVED_PRODUCTION_COORDINATOR_BINARY_HASH = "92237e1cc0d528a12288ff5a2d99eff38ab387080d31eb4146526daa6c973860".toLowerCase() ;
+
+// src/presets/productionMrtd.ts
+var APPROVED_PRODUCTION_COORDINATOR_MRTD = "a2e61f1316e9e367e9c1f7a0adc98c48eb13875c399c85d286cee5ea2b05e57f2df9f61d903b0ae7ac5607d843dfffc1".toLowerCase() ;
+
+// src/session/publicReleasePolicy.ts
+function publicProductionReleasePolicy() {
+  return {
+    expectedMrtd: APPROVED_PRODUCTION_COORDINATOR_MRTD,
+    expectedBinaryHash: APPROVED_PRODUCTION_COORDINATOR_BINARY_HASH,
+    expectedRuntimeProfile: APPROVED_PRODUCTION_RUNTIME_PROFILE
+  };
+}
+
+// src/session/publicSession.ts
+var PUBLIC_SESSION_OPTION_KEYS = /* @__PURE__ */ new Set(["coordinatorUrl", "storage", "wallet"]);
+var PUBLIC_COORDINATOR_URL_PROTOCOL = "wss:";
+var PUBLIC_COORDINATOR_URL_ERROR = "public SDK createSession requires a non-loopback wss:// coordinatorUrl";
+async function createSession(options) {
+  assertPublicOptions(options);
+  const parsedUrl = parsePublicCoordinatorUrl(options.coordinatorUrl);
+  const releasePolicy = publicProductionReleasePolicy();
+  const endpoint = createAzureProductionEndpoint({
+    wsUrl: options.coordinatorUrl,
+    expectedHostname: parsedUrl.hostname,
+    approvedBinaryHash: releasePolicy.expectedBinaryHash,
+    approvedMrtd: releasePolicy.expectedMrtd
+  });
+  const internalOptions = {
+    coordinator: { endpoints: [endpoint] },
+    ...options.storage === void 0 ? {} : { storage: options.storage },
+    ...options.wallet === void 0 ? {} : { wallet: options.wallet }
+  };
+  return createSessionInternal(internalOptions);
+}
+function assertPublicOptions(options) {
+  if (typeof options !== "object" || options === null || Array.isArray(options)) {
+    throw new TypeError("public SDK createSession options must be an object");
+  }
+  for (const key of Object.keys(options)) {
+    if (!PUBLIC_SESSION_OPTION_KEYS.has(key)) {
+      throw new Error(`public SDK createSession does not accept option ${key}`);
+    }
+  }
+  const coordinatorUrl = options.coordinatorUrl;
+  if (typeof coordinatorUrl !== "string") {
+    throw new TypeError("public SDK createSession requires coordinatorUrl");
+  }
+}
+function parsePublicCoordinatorUrl(value) {
+  let parsed;
+  try {
+    parsed = new URL(value);
+  } catch (cause) {
+    const error = new Error(PUBLIC_COORDINATOR_URL_ERROR);
+    error.cause = cause;
+    throw error;
+  }
+  if (parsed.protocol !== PUBLIC_COORDINATOR_URL_PROTOCOL || isLoopbackUrl(value)) {
+    throw new Error(PUBLIC_COORDINATOR_URL_ERROR);
+  }
+  return parsed;
+}
+
+// src/attestation/public.ts
 var attestation = {
-  /**
-   * Force-verify the current session against the active policy by re-running
-   * attestation over the live channel. Updates the stored result on success.
-   *
-   * @throws AttestationError if verification fails.
-   * @throws TransportError if the session has no live attested channel.
-   */
+  productionPolicy() {
+    return publicProductionReleasePolicy();
+  },
   async assertValid(session) {
     const state = getSessionState(session);
     const endpoint = state.pool.endpoints[0];
@@ -74,19 +136,25 @@ var attestation = {
       throw error;
     }
   },
-  /** The last verified attestation result, or `null` before first attestation. */
   current(session) {
     return getSessionState(session).attestation;
   },
-  /** The release pin the active leader endpoint is verified against. Read-only. */
   policy(session) {
-    return getSessionState(session).pool.endpoints[0].releasePin;
+    const pin = getSessionState(session).pool.endpoints[0].releasePin;
+    return {
+      expectedMrtd: pin.mrtd,
+      ...pin.binaryHash === void 0 ? {} : { expectedBinaryHash: pin.binaryHash },
+      ...pin.runtimeProfile === void 0 ? {} : { expectedRuntimeProfile: pin.runtimeProfile },
+      ...pin.intelRootFingerprint === void 0 ? {} : { intelRootFingerprint: pin.intelRootFingerprint },
+      ...pin.azureMaa === void 0 ? {} : {
+        azureMaa: {
+          expectedIssuer: pin.azureMaa.issuer,
+          expectedJwksUrl: pin.azureMaa.jwksUrl,
+          expectedPolicyHash: pin.azureMaa.policyHash
+        }
+      }
+    };
   },
-  /**
-   * Subscribe to out-of-band attestation failures (e.g. during periodic
-   * re-attestation). The handler fires with the verification error; returns an
-   * unsubscribe function.
-   */
   onPolicyViolation(session, handler) {
     const handlers = getSessionState(session).policyViolationHandlers;
     handlers.add(handler);
@@ -94,39 +162,26 @@ var attestation = {
   }
 };
 
-// src/coordinator/index.ts
+// src/coordinator/public.ts
 var coordinator = {
-  /** All configured endpoints, in the order supplied. Read-only. */
   endpoints(session) {
-    return getSessionState(session).pool.endpoints;
+    return getSessionState(session).pool.endpoints.map((endpoint) => ({
+      coordinatorUrl: endpoint.wsUrl,
+      ...endpoint.roleHint === void 0 ? {} : { roleHint: endpoint.roleHint },
+      ...endpoint.weight === void 0 ? {} : { weight: endpoint.weight }
+    }));
   },
-  /**
-   * The endpoint currently accepting mutating commands.
-   *
-   * @throws NotImplementedError - deferred (coordinator-pending).
-   */
   currentLeader(_session) {
     return Promise.reject(new NotImplementedError("coordinator.currentLeader"));
   },
-  /**
-   * The coordinator-reported version snapshot.
-   *
-   * @throws NotImplementedError - deferred (coordinator-pending).
-   */
   version(_session) {
     return Promise.reject(new NotImplementedError("coordinator.version"));
   },
-  /**
-   * Tear down the active session and reconnect through the next healthy
-   * endpoint, forcing a fresh attestation.
-   *
-   * @throws NotImplementedError - deferred (coordinator-pending).
-   */
   forceFailover(_session) {
     return Promise.reject(new NotImplementedError("coordinator.forceFailover"));
   }
 };
 
-export { apiVersion, attestation, coordinator, inMemoryTransport, isAttested };
+export { apiVersion, attestation, coordinator, createSession, inMemoryTransport, isAttested };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map