lody 0.62.0 → 0.63.0

package/dist/chunks/share-link-U1EVLOdF.js

@@ -1,974 +0,0 @@
-import { s as deriveSessionKeyBytes, q as decryptEnvelopeV1, l as computeBlobDigest, d as CodeSessionError, t as encryptEnvelopeV1, P as utf8Decode, Q as utf8Encode, k as canonicalJson, cN as getSubtle, cO as toArrayBuffer, f as base64urlEncode, N as signHostPresence, Y as verifyHostPresence, c as validateMailboxSegment, I as randomBytes, D as DEFAULT_CODE_COLLAB_FEATURES_V1, w as generateContentKey, V as verifierFromPrivateKey, y as generateSigningPrivateKey, x as generatePreferredSigningPrivateKey, C as CORE_CODE_COLLAB_FEATURES_V1, a as validateSpaceUuid, R as validateBlobPathPrefix, v as validateBucketId, b as validateStreamPrefix, e as base64urlDecode, j as buildStreamPrefix, S as validateSerializedSigningPrivateKey, T as validateSerializedVerifierKey, __tla as __tla_0 } from "../index.js";
-let serializeShareLinkV1, unwrapEncryptedEphemeralStateEnvelopeV1, validateShareLinkSecretV1, validateShareServerUrl, verifyHostPresenceV1, REQUIRED_CORE_CODE_COLLAB_FEATURES_V1, assertCompatibleSessionStateV1, assertSessionNotExpiredV1, assertShareLinkMatchesSessionStateV1, buildBlobEnvelopeAadV1, buildEphemeralEnvelopeAadV1, computeEphemeralStateKeyV1, createCursorStateV1, createEncryptedEphemeralStateEnvelopeV1, createHostPresenceV1, createInitialSessionStateV1, createKeyId, createParticipantPresenceV1, createSelectionStateV1, createShareLinkSecretV1, decryptBlobObjectV1, decryptEphemeralPayloadV1, encryptBlobObjectV1, encryptEphemeralPayloadV1, generateHostSessionSecretsV1, parseCursorStateV1, parseEncryptedBlobObjectV1, parseHostPresenceV1, parseParticipantPresenceV1, parseSelectionStateV1, parseShareLinkV1, serializeEncryptedBlobObjectV1;
-let __tla = Promise.all([
-  (() => {
-    try {
-      return __tla_0;
-    } catch {
-    }
-  })()
-]).then(async () => {
-  buildBlobEnvelopeAadV1 = function(input) {
-    return {
-      v: 1,
-      kind: "blob",
-      spaceUuid: input.spaceUuid,
-      fileId: input.fileId,
-      digest: input.digest,
-      kid: input.kid
-    };
-  };
-  encryptBlobObjectV1 = async function(input) {
-    const digest = await computeBlobDigest(input.contentKey, input.plaintext);
-    const blobKey = await deriveSessionKeyBytes(input.contentKey, "blob");
-    const envelope = await encryptEnvelopeV1({
-      keyBytes: blobKey,
-      kid: input.contentKeyId,
-      aad: buildBlobEnvelopeAadV1({
-        spaceUuid: input.spaceUuid,
-        fileId: input.fileId,
-        digest,
-        kid: input.contentKeyId
-      }),
-      plaintext: input.plaintext,
-      nonce: input.nonce
-    });
-    return {
-      digest,
-      envelope
-    };
-  };
-  decryptBlobObjectV1 = async function(input) {
-    const blobKey = await deriveSessionKeyBytes(input.contentKey, "blob");
-    const plaintext = await decryptEnvelopeV1({
-      keyBytes: blobKey,
-      envelope: input.envelope,
-      expectedAad: buildBlobEnvelopeAadV1({
-        spaceUuid: input.spaceUuid,
-        fileId: input.fileId,
-        digest: input.digest,
-        kid: input.envelope.kid
-      })
-    });
-    const actualDigest = await computeBlobDigest(input.contentKey, plaintext);
-    if (actualDigest !== input.digest) {
-      throw new CodeSessionError("blob_digest_mismatch", "Blob plaintext digest does not match BlobRef");
-    }
-    return plaintext;
-  };
-  serializeEncryptedBlobObjectV1 = function(object) {
-    return utf8Encode(canonicalJson(object));
-  };
-  parseEncryptedBlobObjectV1 = function(bytes) {
-    const parsed = JSON.parse(utf8Decode(bytes));
-    if (!parsed || typeof parsed !== "object") {
-      throw new CodeSessionError("invalid_blob_object", "Encrypted blob object must be an object");
-    }
-    const value = parsed;
-    if (typeof value.digest !== "string" || !isEncryptedEnvelopeV1$1(value.envelope)) {
-      throw new CodeSessionError("invalid_blob_object", "Encrypted blob object is malformed");
-    }
-    return {
-      digest: value.digest,
-      envelope: value.envelope
-    };
-  };
-  function isEncryptedEnvelopeV1$1(value) {
-    if (!value || typeof value !== "object") return false;
-    const envelope = value;
-    return envelope.v === 1 && envelope.alg === "A256GCM" && typeof envelope.kid === "string" && typeof envelope.nonce === "string" && typeof envelope.aad === "string" && typeof envelope.ciphertext === "string";
-  }
-  buildEphemeralEnvelopeAadV1 = function(input) {
-    return {
-      v: 1,
-      kind: "ephemeral",
-      spaceUuid: input.spaceUuid,
-      streamId: input.streamId,
-      channel: input.channel,
-      kid: input.kid
-    };
-  };
-  computeEphemeralStateKeyV1 = async function(input) {
-    const ephemeralKey = await deriveSessionKeyBytes(input.contentKey, "ephemeral");
-    const key = await getSubtle().importKey("raw", toArrayBuffer(ephemeralKey), {
-      name: "HMAC",
-      hash: "SHA-256"
-    }, false, [
-      "sign"
-    ]);
-    const payload = utf8Encode(canonicalJson({
-      v: 1,
-      kind: "ephemeral-state-key",
-      spaceUuid: input.spaceUuid,
-      streamId: input.streamId,
-      channel: input.channel,
-      subject: input.subject
-    }));
-    const signature = await getSubtle().sign("HMAC", key, toArrayBuffer(payload));
-    return `esk1-${base64urlEncode(new Uint8Array(signature))}`;
-  };
-  createEncryptedEphemeralStateEnvelopeV1 = function(input) {
-    if (!input.stateKey.startsWith("esk1-")) {
-      throw new CodeSessionError("invalid_ephemeral_state_key", "Ephemeral state key is invalid");
-    }
-    return {
-      v: 1,
-      kind: "loro-code-collab/ephemeral-state",
-      stateKey: input.stateKey,
-      envelope: input.envelope
-    };
-  };
-  unwrapEncryptedEphemeralStateEnvelopeV1 = function(value) {
-    if (isEncryptedEnvelopeV1(value)) return value;
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-      throw new CodeSessionError("invalid_ephemeral_envelope", "Ephemeral envelope must be an object");
-    }
-    const record = value;
-    if (record.v !== 1 || record.kind !== "loro-code-collab/ephemeral-state" || typeof record.stateKey !== "string" || !isEncryptedEnvelopeV1(record.envelope)) {
-      throw new CodeSessionError("invalid_ephemeral_envelope", "Invalid ephemeral state envelope");
-    }
-    return record.envelope;
-  };
-  encryptEphemeralPayloadV1 = async function(input) {
-    const ephemeralKey = await deriveSessionKeyBytes(input.contentKey, "ephemeral");
-    return encryptEnvelopeV1({
-      keyBytes: ephemeralKey,
-      kid: input.contentKeyId,
-      aad: buildEphemeralEnvelopeAadV1({
-        spaceUuid: input.spaceUuid,
-        streamId: input.streamId,
-        channel: input.channel,
-        kid: input.contentKeyId
-      }),
-      plaintext: input.plaintext,
-      nonce: input.nonce
-    });
-  };
-  decryptEphemeralPayloadV1 = async function(input) {
-    const ephemeralKey = await deriveSessionKeyBytes(input.contentKey, "ephemeral");
-    return decryptEnvelopeV1({
-      keyBytes: ephemeralKey,
-      envelope: input.envelope,
-      expectedAad: buildEphemeralEnvelopeAadV1({
-        spaceUuid: input.spaceUuid,
-        streamId: input.streamId,
-        channel: input.channel,
-        kid: input.envelope.kid
-      })
-    });
-  };
-  createHostPresenceV1 = async function(input) {
-    const signed = await signHostPresence(input);
-    return {
-      peerId: input.peerId,
-      hostEpoch: input.hostEpoch,
-      kind: "host",
-      status: "online",
-      updatedAt: signed.updatedAt,
-      nonce: signed.nonce,
-      keyId: signed.keyId,
-      signature: signed.signature
-    };
-  };
-  verifyHostPresenceV1 = async function(input) {
-    if (input.presence.kind !== "host" || input.presence.status !== "online") return false;
-    return verifyHostPresence({
-      verifier: input.verifier,
-      signed: {
-        keyId: input.presence.keyId,
-        updatedAt: input.presence.updatedAt,
-        nonce: input.presence.nonce,
-        signature: input.presence.signature
-      },
-      spaceUuid: input.spaceUuid,
-      peerId: input.presence.peerId,
-      hostEpoch: input.presence.hostEpoch,
-      maxSkewMs: input.maxSkewMs,
-      now: input.now
-    });
-  };
-  parseHostPresenceV1 = function(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-      throw new CodeSessionError("invalid_presence", "Host presence must be an object");
-    }
-    const presence = value;
-    if (typeof presence.peerId !== "string" || typeof presence.hostEpoch !== "string" || presence.kind !== "host" || presence.status !== "online" || typeof presence.updatedAt !== "number" || typeof presence.nonce !== "string" || typeof presence.keyId !== "string" || typeof presence.signature !== "string") {
-      throw new CodeSessionError("invalid_presence", "Invalid host presence payload");
-    }
-    validatePresenceMailboxSegment(presence.peerId, "peerId");
-    validatePresenceMailboxSegment(presence.hostEpoch, "hostEpoch");
-    if (!isSafeTimestamp(presence.updatedAt)) {
-      throw new CodeSessionError("invalid_presence", "Host presence updatedAt must be a non-negative safe integer");
-    }
-    return {
-      peerId: presence.peerId,
-      hostEpoch: presence.hostEpoch,
-      kind: "host",
-      status: "online",
-      updatedAt: presence.updatedAt,
-      nonce: presence.nonce,
-      keyId: presence.keyId,
-      signature: presence.signature
-    };
-  };
-  function isEncryptedEnvelopeV1(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value)) return false;
-    const envelope = value;
-    return envelope.v === 1 && envelope.alg === "A256GCM" && typeof envelope.kid === "string" && typeof envelope.nonce === "string" && typeof envelope.aad === "string" && typeof envelope.ciphertext === "string";
-  }
-  createParticipantPresenceV1 = function(input) {
-    validatePresenceMailboxSegment(input.peerId, "peerId");
-    if (!isSafeTimestamp(input.updatedAt)) {
-      throw new CodeSessionError("invalid_presence", "Participant presence updatedAt must be a non-negative safe integer");
-    }
-    return {
-      v: 1,
-      kind: "participant",
-      peerId: input.peerId,
-      role: input.role,
-      ...input.inviteId === void 0 ? {} : {
-        inviteId: input.inviteId
-      },
-      ...input.displayName === void 0 ? {} : {
-        displayName: input.displayName
-      },
-      ...input.color === void 0 ? {} : {
-        color: input.color
-      },
-      ...input.activeFileId === void 0 ? {} : {
-        activeFileId: input.activeFileId
-      },
-      updatedAt: input.updatedAt,
-      ...input.identity === void 0 ? {} : {
-        identity: input.identity
-      }
-    };
-  };
-  createCursorStateV1 = function(input) {
-    validatePresenceMailboxSegment(input.peerId, "peerId");
-    if (!isSafeTimestamp(input.updatedAt)) {
-      throw new CodeSessionError("invalid_cursor", "Cursor updatedAt must be a non-negative safe integer");
-    }
-    return {
-      v: 1,
-      kind: "cursor",
-      peerId: input.peerId,
-      fileId: input.fileId,
-      anchor: input.anchor,
-      ...input.head === void 0 ? {} : {
-        head: input.head
-      },
-      updatedAt: input.updatedAt
-    };
-  };
-  createSelectionStateV1 = function(input) {
-    validatePresenceMailboxSegment(input.peerId, "peerId");
-    if (!isSafeTimestamp(input.updatedAt)) {
-      throw new CodeSessionError("invalid_selection", "Selection updatedAt must be a non-negative safe integer");
-    }
-    return {
-      v: 1,
-      kind: "selection",
-      peerId: input.peerId,
-      fileId: input.fileId,
-      anchor: input.anchor,
-      head: input.head,
-      updatedAt: input.updatedAt
-    };
-  };
-  parseParticipantPresenceV1 = function(value) {
-    const record = requireRecord(value, "Participant presence");
-    if (record.v !== 1 || record.kind !== "participant" || typeof record.peerId !== "string" || !isPresenceRole(record.role) || !isSafeTimestamp(record.updatedAt)) {
-      throw new CodeSessionError("invalid_presence", "Invalid participant presence payload");
-    }
-    return createParticipantPresenceV1({
-      peerId: record.peerId,
-      role: record.role,
-      inviteId: optionalString(record.inviteId, "inviteId"),
-      displayName: optionalString(record.displayName, "displayName"),
-      color: optionalString(record.color, "color"),
-      activeFileId: optionalString(record.activeFileId, "activeFileId"),
-      identity: parseOptionalIdentity(record.identity),
-      updatedAt: record.updatedAt
-    });
-  };
-  parseCursorStateV1 = function(value) {
-    const record = requireRecord(value, "Cursor state");
-    if (record.v !== 1 || record.kind !== "cursor" || typeof record.peerId !== "string" || typeof record.fileId !== "string" || !isSafeTimestamp(record.updatedAt)) {
-      throw new CodeSessionError("invalid_cursor", "Invalid cursor state payload");
-    }
-    return createCursorStateV1({
-      peerId: record.peerId,
-      fileId: record.fileId,
-      anchor: parseCursorAnchor(record.anchor),
-      head: record.head === void 0 ? void 0 : parseCursorAnchor(record.head),
-      updatedAt: record.updatedAt
-    });
-  };
-  parseSelectionStateV1 = function(value) {
-    const record = requireRecord(value, "Selection state");
-    if (record.v !== 1 || record.kind !== "selection" || typeof record.peerId !== "string" || typeof record.fileId !== "string" || !isSafeTimestamp(record.updatedAt)) {
-      throw new CodeSessionError("invalid_selection", "Invalid selection state payload");
-    }
-    return createSelectionStateV1({
-      peerId: record.peerId,
-      fileId: record.fileId,
-      anchor: parseCursorAnchor(record.anchor),
-      head: parseCursorAnchor(record.head),
-      updatedAt: record.updatedAt
-    });
-  };
-  function requireRecord(value, label) {
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-      throw new CodeSessionError("invalid_ephemeral_state", `${label} must be an object`);
-    }
-    return value;
-  }
-  function parseCursorAnchor(value) {
-    const record = requireRecord(value, "Cursor anchor");
-    if (typeof record.offset !== "number" || !Number.isFinite(record.offset) || record.offset < 0) {
-      throw new CodeSessionError("invalid_cursor", "Cursor anchor offset must be a non-negative number");
-    }
-    return {
-      offset: Math.trunc(record.offset),
-      ...record.loroCursor === void 0 ? {} : {
-        loroCursor: parseEncodedLoroCursor(record.loroCursor)
-      }
-    };
-  }
-  function parseEncodedLoroCursor(value) {
-    const record = requireRecord(value, "Loro cursor anchor");
-    if (record.v !== 1 || record.kind !== "loro-cursor" || typeof record.encoded !== "string" || record.encoded.length === 0) {
-      throw new CodeSessionError("invalid_cursor", "Invalid Loro cursor anchor");
-    }
-    return {
-      v: 1,
-      kind: "loro-cursor",
-      encoded: record.encoded
-    };
-  }
-  function parseOptionalIdentity(value) {
-    if (value === void 0) return void 0;
-    const record = requireRecord(value, "Participant identity");
-    if (record.mode !== "anonymous" && record.mode !== "verified") {
-      throw new CodeSessionError("invalid_presence", "Invalid participant identity mode");
-    }
-    return {
-      mode: record.mode,
-      ...optionalStringField("issuer", record.issuer),
-      ...optionalStringField("subject", record.subject),
-      ...optionalStringField("userId", record.userId),
-      ...optionalStringField("displayName", record.displayName),
-      ...optionalStringField("avatarUrl", record.avatarUrl)
-    };
-  }
-  function optionalString(value, field) {
-    if (value === void 0) return void 0;
-    if (typeof value !== "string") {
-      throw new CodeSessionError("invalid_presence", `${field} must be a string`);
-    }
-    return value;
-  }
-  function optionalStringField(key, value) {
-    const parsed = optionalString(value, key);
-    return parsed === void 0 ? {} : {
-      [key]: parsed
-    };
-  }
-  function isPresenceRole(value) {
-    return value === "host" || value === "write" || value === "read";
-  }
-  function validatePresenceMailboxSegment(value, label) {
-    try {
-      validateMailboxSegment(value, label);
-    } catch {
-      throw new CodeSessionError("invalid_presence", `${label} is invalid`);
-    }
-  }
-  function isSafeTimestamp(value) {
-    return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
-  }
-  generateHostSessionSecretsV1 = async function(options = {}) {
-    const contentKey = options.contentKey ?? generateContentKey();
-    const contentKeyId = options.contentKeyId ?? createKeyId("ck");
-    const [readSigningKey, writeSigningKey, hostPresenceSigningKey] = await Promise.all([
-      generateSessionSigningKey({
-        alg: options.alg,
-        keyId: options.readKeyId ?? createKeyId("read")
-      }),
-      generateSessionSigningKey({
-        alg: options.alg,
-        keyId: options.writeKeyId ?? createKeyId("write")
-      }),
-      generateSessionSigningKey({
-        alg: options.alg,
-        keyId: options.hostPresenceKeyId ?? createKeyId("host")
-      })
-    ]);
-    const hostPresenceVerifier = verifierFromPrivateKey(hostPresenceSigningKey);
-    return {
-      v: 1,
-      contentKey: base64urlEncode(contentKey),
-      contentKeyId,
-      readSigningKey,
-      writeSigningKey,
-      hostPresenceSigningKey,
-      hostPresenceVerifier,
-      createShareSecret(input) {
-        return createShareLinkSecretV1({
-          contentKey: base64urlEncode(contentKey),
-          contentKeyId,
-          readSigningKey,
-          writeSigningKey,
-          hostPresenceVerifier,
-          ...input
-        });
-      }
-    };
-  };
-  createShareLinkSecretV1 = function(input) {
-    const base = {
-      v: 1,
-      kind: "loro-code-collab/share-secret",
-      inviteId: input.inviteId,
-      role: input.role,
-      contentKey: input.contentKey,
-      contentKeyId: input.contentKeyId,
-      readSigningKey: input.readSigningKey,
-      hostPresenceVerifier: input.hostPresenceVerifier,
-      features: {
-        ...DEFAULT_CODE_COLLAB_FEATURES_V1,
-        ...input.features
-      }
-    };
-    const secretBase = input.expiresAt === void 0 ? base : {
-      ...base,
-      expiresAt: input.expiresAt
-    };
-    if (input.role === "read") {
-      return secretBase;
-    }
-    return {
-      ...secretBase,
-      writeSigningKey: input.writeSigningKey
-    };
-  };
-  createKeyId = function(prefix) {
-    return `${prefix}-${base64urlEncode(randomBytes(8))}`;
-  };
-  async function generateSessionSigningKey(input) {
-    if (input.alg) {
-      return generateSigningPrivateKey({
-        alg: input.alg,
-        keyId: input.keyId
-      });
-    }
-    return generatePreferredSigningPrivateKey({
-      keyId: input.keyId
-    });
-  }
-  const UTC_RFC3339_MILLIS_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/u;
-  function parseUtcRfc3339Millis(value, label, code) {
-    if (!UTC_RFC3339_MILLIS_RE.test(value)) {
-      throw new CodeSessionError(code, `${label} must be a valid UTC RFC3339 timestamp`);
-    }
-    const ms = Date.parse(value);
-    if (!Number.isFinite(ms) || new Date(ms).toISOString() !== value) {
-      throw new CodeSessionError(code, `${label} must be a valid UTC RFC3339 timestamp`);
-    }
-    return ms;
-  }
-  REQUIRED_CORE_CODE_COLLAB_FEATURES_V1 = Object.keys(CORE_CODE_COLLAB_FEATURES_V1);
-  createInitialSessionStateV1 = function(input) {
-    const readVerifier = verifierFromPrivateKey(input.secrets.readSigningKey);
-    if (!input.secrets.writeSigningKey) {
-      throw new CodeSessionError("invalid_share_secret", "Host session secret material is missing write signing key");
-    }
-    const writeVerifier = verifierFromPrivateKey(input.secrets.writeSigningKey);
-    const hostPresenceVerifier = input.secrets.hostPresenceVerifier;
-    const invite = {
-      inviteId: input.inviteId,
-      role: input.inviteRole,
-      readVerifierKeyId: readVerifier.keyId,
-      ...input.expiresAt === void 0 ? {} : {
-        expiresAt: input.expiresAt
-      },
-      ...input.inviteRole === "write" ? {
-        writeVerifierKeyId: writeVerifier.keyId
-      } : {}
-    };
-    return {
-      protocolVersion: 1,
-      mode: "hosted-code-session",
-      spaceUuid: input.spaceUuid,
-      createdAt: input.createdAt,
-      ...input.expiresAt === void 0 ? {} : {
-        expiresAt: input.expiresAt
-      },
-      ...input.hostLivenessTimeoutMs === void 0 ? {} : {
-        hostLivenessTimeoutMs: input.hostLivenessTimeoutMs
-      },
-      host: {
-        peerId: input.hostPeerId,
-        hostEpoch: input.hostEpoch,
-        presenceVerifierKeyId: hostPresenceVerifier.keyId
-      },
-      crypto: {
-        contentKeyId: input.secrets.contentKeyId,
-        readVerifierKeyId: readVerifier.keyId,
-        writeVerifierKeyId: writeVerifier.keyId,
-        hostPresenceVerifierKeyId: hostPresenceVerifier.keyId,
-        verifierKeys: {
-          [readVerifier.keyId]: toSessionVerifierKey(readVerifier, "read"),
-          [writeVerifier.keyId]: toSessionVerifierKey(writeVerifier, "write"),
-          [hostPresenceVerifier.keyId]: toSessionVerifierKey(hostPresenceVerifier, "host-presence")
-        }
-      },
-      invites: {
-        [input.inviteId]: invite
-      },
-      participants: {
-        [input.hostPeerId]: {
-          peerId: input.hostPeerId,
-          role: "host",
-          joinedAt: input.createdAt,
-          capabilities: [
-            "host",
-            "hydrate_text",
-            "hydrate_blob",
-            "lsp_definition",
-            "lsp_references",
-            "save_text",
-            "resolve_save_conflict"
-          ]
-        }
-      },
-      features: {
-        ...DEFAULT_CODE_COLLAB_FEATURES_V1,
-        ...input.features
-      }
-    };
-  };
-  assertCompatibleSessionStateV1 = function(state, requiredFeaturesOrOptions = REQUIRED_CORE_CODE_COLLAB_FEATURES_V1) {
-    assertSessionStateShape(state);
-    const options = isReadonlyStringArray(requiredFeaturesOrOptions) ? {
-      requiredFeatures: requiredFeaturesOrOptions
-    } : requiredFeaturesOrOptions;
-    const requiredFeatures = options.requiredFeatures ?? REQUIRED_CORE_CODE_COLLAB_FEATURES_V1;
-    if (state.protocolVersion !== 1) {
-      throw new CodeSessionError("unsupported_protocol_version", `Unsupported code collaboration protocol version: ${String(state.protocolVersion)}`);
-    }
-    if (state.mode !== "hosted-code-session") {
-      throw new CodeSessionError("unsupported_session_mode", `Unsupported code collaboration session mode: ${String(state.mode)}`);
-    }
-    parseRfc3339TimestampMs(state.createdAt, "createdAt");
-    if (state.expiresAt !== void 0) {
-      parseRfc3339TimestampMs(state.expiresAt, "expiresAt");
-    }
-    if (state.hostLivenessTimeoutMs !== void 0 && (!Number.isSafeInteger(state.hostLivenessTimeoutMs) || state.hostLivenessTimeoutMs < 0)) {
-      throw new CodeSessionError("invalid_session_state", "hostLivenessTimeoutMs must be a non-negative safe integer");
-    }
-    validateSpaceUuid(state.spaceUuid);
-    if (options.spaceUuid !== void 0 && state.spaceUuid.toLowerCase() !== options.spaceUuid.toLowerCase()) {
-      throw new CodeSessionError("session_route_mismatch", "Session state spaceUuid does not match share link route");
-    }
-    validateMailboxSegment(state.host.peerId, "host.peerId");
-    validateMailboxSegment(state.host.hostEpoch, "host.hostEpoch");
-    assertSessionVerifierKey(state, state.crypto.readVerifierKeyId, "read", "readVerifierKeyId");
-    assertSessionVerifierKey(state, state.crypto.writeVerifierKeyId, "write", "writeVerifierKeyId");
-    assertSessionVerifierKey(state, state.crypto.hostPresenceVerifierKeyId, "host-presence", "hostPresenceVerifierKeyId");
-    assertSessionVerifierKey(state, state.host.presenceVerifierKeyId, "host-presence", "host.presenceVerifierKeyId");
-    validateInvites(state);
-    validateParticipants(state);
-    validateSessionFeatures(state.features);
-    for (const feature of requiredFeatures) {
-      if (!state.features[feature]) {
-        throw new CodeSessionError("missing_required_feature", `Session is missing required feature: ${feature}`);
-      }
-    }
-  };
-  function assertSessionVerifierKey(state, keyId, purpose, label) {
-    if (!keyId || typeof keyId !== "string") {
-      throw new CodeSessionError("invalid_session_state", `${label} must be a non-empty string`);
-    }
-    const verifier = state.crypto.verifierKeys[keyId];
-    assertRecord(verifier, `verifier key ${keyId}`);
-    if (verifier.alg !== "ed25519" && verifier.alg !== "p256") {
-      throw new CodeSessionError("invalid_session_state", `verifier key ${keyId} has unsupported alg`);
-    }
-    if (verifier.purpose !== purpose) {
-      throw new CodeSessionError("invalid_session_state", `verifier key ${keyId} purpose mismatch`);
-    }
-    if (!verifier.publicKey || typeof verifier.publicKey !== "string") {
-      throw new CodeSessionError("invalid_session_state", `verifier key ${keyId} publicKey must be a string`);
-    }
-    if ("privateKey" in verifier) {
-      throw new CodeSessionError("invalid_session_state", `verifier key ${keyId} must not include privateKey`);
-    }
-  }
-  function validateInvites(state) {
-    for (const [inviteId, invite] of Object.entries(state.invites)) {
-      assertRecord(invite, `invite ${inviteId}`);
-      if (invite.inviteId !== inviteId || !invite.inviteId || typeof invite.inviteId !== "string") {
-        throw new CodeSessionError("invalid_session_state", `invite ${inviteId} inviteId mismatch`);
-      }
-      if (invite.role !== "read" && invite.role !== "write") {
-        throw new CodeSessionError("invalid_session_state", `invite ${inviteId} role must be read or write`);
-      }
-      if (invite.expiresAt !== void 0) {
-        parseRfc3339TimestampMs(invite.expiresAt, `invite ${inviteId} expiresAt`);
-      }
-      assertSessionVerifierKey(state, invite.readVerifierKeyId, "read", `invite ${inviteId} readVerifierKeyId`);
-      if (invite.role === "read") {
-        if (invite.writeVerifierKeyId !== void 0) {
-          throw new CodeSessionError("invalid_session_state", `invite ${inviteId} read role must not include writeVerifierKeyId`);
-        }
-      } else {
-        if (typeof invite.writeVerifierKeyId !== "string") {
-          throw new CodeSessionError("invalid_session_state", `invite ${inviteId} write role must include writeVerifierKeyId`);
-        }
-        assertSessionVerifierKey(state, invite.writeVerifierKeyId, "write", `invite ${inviteId} writeVerifierKeyId`);
-      }
-      if (invite.maxUses !== void 0 && (!Number.isSafeInteger(invite.maxUses) || invite.maxUses < 0)) {
-        throw new CodeSessionError("invalid_session_state", `invite ${inviteId} maxUses must be non-negative`);
-      }
-    }
-  }
-  function validateParticipants(state) {
-    if (!state.participants) return;
-    for (const [peerId, participant] of Object.entries(state.participants)) {
-      assertRecord(participant, `participant ${peerId}`);
-      if (participant.peerId !== peerId) {
-        throw new CodeSessionError("invalid_session_state", `participant ${peerId} peerId mismatch`);
-      }
-      validateMailboxSegment(participant.peerId, `participant ${peerId}.peerId`);
-      if (participant.role !== "host" && participant.role !== "write" && participant.role !== "read") {
-        throw new CodeSessionError("invalid_session_state", `participant ${peerId} role is invalid`);
-      }
-      if (participant.joinedAt !== void 0) {
-        parseRfc3339TimestampMs(participant.joinedAt, `participant ${peerId} joinedAt`);
-      }
-      if (participant.capabilities !== void 0 && (!Array.isArray(participant.capabilities) || participant.capabilities.some((capability) => typeof capability !== "string" || capability.length === 0))) {
-        throw new CodeSessionError("invalid_session_state", `participant ${peerId} capabilities are invalid`);
-      }
-      if (participant.inviteId !== void 0 && typeof participant.inviteId !== "string") {
-        throw new CodeSessionError("invalid_session_state", `participant ${peerId} inviteId must be a string`);
-      }
-    }
-  }
-  function validateSessionFeatures(features) {
-    for (const [feature, enabled] of Object.entries(features)) {
-      if (!feature || typeof enabled !== "boolean") {
-        throw new CodeSessionError("invalid_session_state", "features must map non-empty names to booleans");
-      }
-    }
-  }
-  function assertSessionStateShape(state) {
-    assertRecord(state, "session state");
-    assertRecord(state.host, "session host");
-    assertRecord(state.crypto, "session crypto");
-    assertRecord(state.crypto.verifierKeys, "session verifier keys");
-    assertRecord(state.invites, "session invites");
-    assertRecord(state.features, "session features");
-    if (state.participants !== void 0) {
-      assertRecord(state.participants, "session participants");
-    }
-  }
-  function assertRecord(value, label) {
-    if (!value || typeof value !== "object" || Array.isArray(value)) {
-      throw new CodeSessionError("invalid_session_state", `${label} must be an object`);
-    }
-  }
-  assertShareLinkMatchesSessionStateV1 = function(state, secret, options = {}) {
-    if (options.routeInviteId !== void 0 && options.routeInviteId !== secret.inviteId) {
-      throw new CodeSessionError("session_invite_mismatch", "Share link route inviteId does not match share secret");
-    }
-    if (state.crypto.contentKeyId !== secret.contentKeyId) {
-      throw new CodeSessionError("session_invite_mismatch", "Share secret contentKeyId does not match session state");
-    }
-    for (const [feature, enabled] of Object.entries(secret.features)) {
-      if (state.features[feature] !== enabled) {
-        throw new CodeSessionError("session_invite_mismatch", `Share feature ${feature} does not match session state`);
-      }
-    }
-    assertNotExpired(state.expiresAt, "session", options);
-    assertNotExpired(secret.expiresAt, "share secret", options);
-    const invite = state.invites[secret.inviteId];
-    if (!invite || invite.inviteId !== secret.inviteId) {
-      throw new CodeSessionError("session_invite_mismatch", "Share invite is not present in session state");
-    }
-    assertNotExpired(invite.expiresAt, "share invite", options);
-    if (invite.role !== secret.role) {
-      throw new CodeSessionError("session_invite_mismatch", "Share invite role does not match session state");
-    }
-    if (invite.readVerifierKeyId !== secret.readSigningKey.keyId) {
-      throw new CodeSessionError("session_invite_mismatch", "Share read signing key does not match session invite");
-    }
-    assertPrivateKeyMatchesSessionVerifier(state, secret.readSigningKey, "read", "Share read signing key");
-    if (secret.role === "read") {
-      if (invite.writeVerifierKeyId !== void 0) {
-        throw new CodeSessionError("session_invite_mismatch", "Read-only share invite must not advertise a write verifier");
-      }
-    } else {
-      const writeSigningKey = secret.writeSigningKey;
-      if (!writeSigningKey || invite.writeVerifierKeyId !== writeSigningKey.keyId) {
-        throw new CodeSessionError("session_invite_mismatch", "Share write signing key does not match session invite");
-      }
-      assertPrivateKeyMatchesSessionVerifier(state, writeSigningKey, "write", "Share write signing key");
-    }
-    if (state.host.presenceVerifierKeyId !== state.crypto.hostPresenceVerifierKeyId || secret.hostPresenceVerifier.keyId !== state.crypto.hostPresenceVerifierKeyId) {
-      throw new CodeSessionError("session_invite_mismatch", "Host presence verifier does not match session state");
-    }
-    assertVerifierMatchesSessionVerifier(state, secret.hostPresenceVerifier, "host-presence", "Host presence verifier");
-  };
-  assertSessionNotExpiredV1 = function(state, options = {}) {
-    assertNotExpired(state.expiresAt, "session", options);
-  };
-  function isReadonlyStringArray(value) {
-    return Array.isArray(value);
-  }
-  function toSessionVerifierKey(verifier, purpose) {
-    return {
-      alg: verifier.alg,
-      purpose,
-      publicKey: verifier.publicKey
-    };
-  }
-  function assertPrivateKeyMatchesSessionVerifier(state, key, purpose, label) {
-    assertVerifierMatchesSessionVerifier(state, verifierFromPrivateKey(key), purpose, label);
-  }
-  function assertVerifierMatchesSessionVerifier(state, verifier, purpose, label) {
-    const sessionVerifier = state.crypto.verifierKeys[verifier.keyId];
-    if (!sessionVerifier) {
-      throw new CodeSessionError("session_invite_mismatch", `${label} is not present in session verifier keys`);
-    }
-    if (sessionVerifier.purpose !== purpose || sessionVerifier.alg !== verifier.alg || sessionVerifier.publicKey !== verifier.publicKey) {
-      throw new CodeSessionError("session_invite_mismatch", `${label} does not match session verifier keys`);
-    }
-  }
-  function assertNotExpired(expiresAt, label, options) {
-    if (expiresAt === void 0 || options.nowMs === void 0) return;
-    const expiresAtMs = parseRfc3339TimestampMs(expiresAt, `${label} expiresAt`);
-    const skewMs = options.maxClockSkewMs ?? 0;
-    if (options.nowMs > expiresAtMs + skewMs) {
-      throw new CodeSessionError("session_expired", `${label} has expired`);
-    }
-  }
-  function parseRfc3339TimestampMs(value, label) {
-    return parseUtcRfc3339Millis(value, label, "invalid_session_state");
-  }
-  serializeShareLinkV1 = function(input) {
-    validateBucketId(input.bucketId);
-    validateSpaceUuid(input.spaceUuid);
-    validateShareServerUrl(input.serverUrl);
-    if (input.blobServerUrl !== void 0) {
-      validateShareServerUrl(input.blobServerUrl);
-    }
-    if (input.blobPathPrefix !== void 0) {
-      validateBlobPathPrefix(input.blobPathPrefix);
-    }
-    validateShareLinkSecretV1(input.secret);
-    const spaceUuid = input.spaceUuid.toLowerCase();
-    const streamPrefix = input.streamPrefix ?? buildStreamPrefix(spaceUuid);
-    validateStreamPrefix(streamPrefix);
-    if (input.inviteId !== input.secret.inviteId) {
-      throw new CodeSessionError("invalid_share_link", "inviteId must match share secret");
-    }
-    const url = new URL("loro://join");
-    url.searchParams.set("v", "1");
-    url.searchParams.set("server", input.serverUrl);
-    url.searchParams.set("bucket", input.bucketId);
-    url.searchParams.set("space", spaceUuid);
-    url.searchParams.set("prefix", streamPrefix);
-    if (input.blobServerUrl !== void 0) {
-      url.searchParams.set("blobServer", input.blobServerUrl);
-    }
-    if (input.blobPathPrefix !== void 0) {
-      url.searchParams.set("blobPrefix", input.blobPathPrefix);
-    }
-    url.searchParams.set("invite", input.inviteId);
-    url.hash = `keys=${base64urlEncode(utf8Encode(canonicalJson(input.secret)))}`;
-    return url.toString();
-  };
-  parseShareLinkV1 = function(link) {
-    let url;
-    try {
-      url = new URL(link);
-    } catch {
-      throw new CodeSessionError("invalid_share_link", "Share link must be a valid loro://join URL");
-    }
-    if (url.protocol !== "loro:" || url.hostname !== "join") {
-      throw new CodeSessionError("invalid_share_link", "Share link must use loro://join");
-    }
-    if (url.searchParams.get("v") !== "1") {
-      throw new CodeSessionError("invalid_share_link", "Share link version must be 1");
-    }
-    const serverUrl = requiredParam(url, "server");
-    validateShareServerUrl(serverUrl);
-    const blobServerUrl = optionalParam(url, "blobServer");
-    if (blobServerUrl !== void 0) {
-      validateShareServerUrl(blobServerUrl);
-    }
-    const blobPathPrefix = optionalParam(url, "blobPrefix");
-    if (blobPathPrefix !== void 0) {
-      validateBlobPathPrefix(blobPathPrefix);
-    }
-    const bucketId = requiredParam(url, "bucket");
-    const spaceUuid = requiredParam(url, "space").toLowerCase();
-    const streamPrefix = requiredParam(url, "prefix");
-    const inviteId = requiredParam(url, "invite");
-    validateBucketId(bucketId);
-    validateSpaceUuid(spaceUuid);
-    validateStreamPrefix(streamPrefix);
-    const hash = url.hash.startsWith("#") ? url.hash.slice(1) : url.hash;
-    const fragment = new URLSearchParams(hash);
-    const keys = fragment.get("keys");
-    if (!keys) {
-      throw new CodeSessionError("invalid_share_link", "Share link fragment is missing keys");
-    }
-    let secret;
-    try {
-      secret = JSON.parse(utf8Decode(base64urlDecode(keys)));
-    } catch {
-      throw new CodeSessionError("invalid_share_link", "Share link fragment contains invalid keys");
-    }
-    validateShareLinkSecretV1(secret);
-    if (secret.inviteId !== inviteId) {
-      throw new CodeSessionError("invalid_share_link", "inviteId must match share secret");
-    }
-    return {
-      route: {
-        v: 1,
-        serverUrl,
-        ...blobServerUrl === void 0 ? {} : {
-          blobServerUrl
-        },
-        ...blobPathPrefix === void 0 ? {} : {
-          blobPathPrefix
-        },
-        bucketId,
-        spaceUuid,
-        streamPrefix,
-        inviteId
-      },
-      secret
-    };
-  };
-  validateShareLinkSecretV1 = function(secret) {
-    if (!secret || typeof secret !== "object" || Array.isArray(secret)) {
-      throw new CodeSessionError("invalid_share_secret", "Share secret must be an object");
-    }
-    if (secret.v !== 1 || secret.kind !== "loro-code-collab/share-secret") {
-      throw new CodeSessionError("invalid_share_secret", "Unsupported share secret");
-    }
-    if (secret.role !== "read" && secret.role !== "write") {
-      throw new CodeSessionError("invalid_share_secret", "Share role must be read or write");
-    }
-    if (!secret.inviteId || !secret.contentKey || !secret.contentKeyId) {
-      throw new CodeSessionError("invalid_share_secret", "Share secret is missing required fields");
-    }
-    if (secret.expiresAt !== void 0) {
-      validateRfc3339Timestamp(secret.expiresAt, "expiresAt");
-    }
-    validateContentKey(secret.contentKey);
-    validateFeatureFlags(secret.features);
-    validateSerializedSigningPrivateKey(secret.readSigningKey);
-    validateSerializedVerifierKey(secret.hostPresenceVerifier);
-    if (secret.role === "read" && secret.writeSigningKey !== void 0) {
-      throw new CodeSessionError("invalid_share_secret", "Read share links must not include writeSigningKey");
-    }
-    if (secret.role === "write") {
-      validateSerializedSigningPrivateKey(secret.writeSigningKey);
-    }
-  };
-  function validateContentKey(contentKey) {
-    let decoded;
-    try {
-      decoded = base64urlDecode(contentKey);
-    } catch {
-      throw new CodeSessionError("invalid_share_secret", "contentKey must be unpadded base64url");
-    }
-    if (decoded.byteLength !== 32) {
-      throw new CodeSessionError("invalid_share_secret", "contentKey must decode to 32 bytes");
-    }
-  }
-  function validateFeatureFlags(features) {
-    if (!features || typeof features !== "object" || Array.isArray(features)) {
-      throw new CodeSessionError("invalid_share_secret", "features must be an object");
-    }
-    for (const [key, value] of Object.entries(features)) {
-      if (!key || typeof value !== "boolean") {
-        throw new CodeSessionError("invalid_share_secret", "features must map feature names to booleans");
-      }
-    }
-  }
-  validateShareServerUrl = function(serverUrl) {
-    let parsed;
-    try {
-      parsed = new URL(serverUrl);
-    } catch {
-      throw new CodeSessionError("invalid_share_link", "Share link server must be a valid URL");
-    }
-    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
-      throw new CodeSessionError("invalid_share_link", "Share link server must use http or https");
-    }
-    if (parsed.username || parsed.password) {
-      throw new CodeSessionError("invalid_share_link", "Share link server must not include credentials");
-    }
-    if (parsed.search || parsed.hash) {
-      throw new CodeSessionError("invalid_share_link", "Share link server must not include query or fragment");
-    }
-    if (parsed.pathname !== "/" && parsed.pathname !== "") {
-      throw new CodeSessionError("invalid_share_link", "Share link server must not include a path");
-    }
-  };
-  function requiredParam(url, key) {
-    const value = url.searchParams.get(key);
-    if (!value) {
-      throw new CodeSessionError("invalid_share_link", `Share link is missing ${key}`);
-    }
-    return value;
-  }
-  function optionalParam(url, key) {
-    const value = url.searchParams.get(key);
-    return value == null || value.length === 0 ? void 0 : value;
-  }
-  function validateRfc3339Timestamp(value, label) {
-    parseUtcRfc3339Millis(value, label, "invalid_share_secret");
-  }
-});
-export {
-  serializeShareLinkV1 as A,
-  unwrapEncryptedEphemeralStateEnvelopeV1 as B,
-  validateShareLinkSecretV1 as C,
-  validateShareServerUrl as D,
-  verifyHostPresenceV1 as E,
-  REQUIRED_CORE_CODE_COLLAB_FEATURES_V1 as R,
-  __tla,
-  assertCompatibleSessionStateV1 as a,
-  assertSessionNotExpiredV1 as b,
-  assertShareLinkMatchesSessionStateV1 as c,
-  buildBlobEnvelopeAadV1 as d,
-  buildEphemeralEnvelopeAadV1 as e,
-  computeEphemeralStateKeyV1 as f,
-  createCursorStateV1 as g,
-  createEncryptedEphemeralStateEnvelopeV1 as h,
-  createHostPresenceV1 as i,
-  createInitialSessionStateV1 as j,
-  createKeyId as k,
-  createParticipantPresenceV1 as l,
-  createSelectionStateV1 as m,
-  createShareLinkSecretV1 as n,
-  decryptBlobObjectV1 as o,
-  decryptEphemeralPayloadV1 as p,
-  encryptBlobObjectV1 as q,
-  encryptEphemeralPayloadV1 as r,
-  generateHostSessionSecretsV1 as s,
-  parseCursorStateV1 as t,
-  parseEncryptedBlobObjectV1 as u,
-  parseHostPresenceV1 as v,
-  parseParticipantPresenceV1 as w,
-  parseSelectionStateV1 as x,
-  parseShareLinkV1 as y,
-  serializeEncryptedBlobObjectV1 as z
-};