@everfur/sdk 0.1.0

package/dist/testing/index.cjs

@@ -0,0 +1,825 @@
+'use strict';
+
+var zod = require('zod');
+
+// src/client/errors/EverfurResult.ts
+function ok(value, warning) {
+  return Object.freeze(
+    { ok: true, value } 
+  );
+}
+function err(error) {
+  return Object.freeze({ ok: false, error });
+}
+var EverfurConfigError = class _EverfurConfigError extends Error {
+  constructor(kind, message) {
+    super(message);
+    this.name = "EverfurConfigError";
+    this.kind = kind;
+    Object.setPrototypeOf(this, _EverfurConfigError.prototype);
+  }
+};
+
+// src/core/testing/knownRoutes.ts
+var KNOWN_PARTNER_ROUTES = [
+  "DELETE /widget/v1/me",
+  "DELETE /widget/v1/pets/{pet_ref}",
+  "DELETE /widget/v1/records/pets/{pet_ref}/consent",
+  "GET /widget/v1/consent",
+  "GET /widget/v1/conversations",
+  "GET /widget/v1/conversations/{conversation_id}/messages",
+  "GET /widget/v1/entitlements",
+  "GET /widget/v1/pets",
+  "GET /widget/v1/records/pets/{pet_ref}/consent",
+  "GET /widget/v1/records/pets/{pet_ref}/record",
+  "GET /widget/v1/records/requests",
+  "GET /widget/v1/records/requests/{request_id}",
+  "GET /widget/v1/suggested-prompts",
+  "PATCH /widget/v1/pets/{pet_ref}",
+  "POST /widget/v1/conversations",
+  "POST /widget/v1/conversations/{conversation_id}/analyze",
+  "POST /widget/v1/conversations/{conversation_id}/classify",
+  "POST /widget/v1/conversations/{conversation_id}/messages",
+  "POST /widget/v1/pets/{pet_ref}",
+  "POST /widget/v1/records/requests",
+  "POST /widget/v1/records/requests/{request_id}/uploads/complete",
+  "POST /widget/v1/records/requests/{request_id}/uploads/initiate",
+  "POST /widget/v1/sessions",
+  "PUT /widget/v1/consent",
+  "PUT /widget/v1/records/pets/{pet_ref}/consent"
+];
+var KNOWN_ABSENT_ROUTES = [
+  "POST /widget/v1/uploads/initiate",
+  "POST /widget/v1/photo/precheck",
+  "POST /widget/v1/photo/analyze",
+  "POST /widget/v1/video/analyze",
+  "GET /widget/v1/analysis/jobs/{job_id}",
+  "GET /widget/v1/pets/{pet_ref}/state"
+];
+function pathMatches(template, path) {
+  const templateParts = template.split("/");
+  const [withoutQuery = ""] = path.split("?");
+  const pathParts = withoutQuery.split("/");
+  if (templateParts.length !== pathParts.length) return false;
+  return templateParts.every((seg, i) => {
+    const actual = pathParts[i];
+    if (actual === void 0) return false;
+    const isWildcard = seg.startsWith("{") && seg.endsWith("}");
+    return isWildcard ? actual.length > 0 : seg === actual;
+  });
+}
+function classifyRoute(method, path) {
+  const matches = (list) => list.some((entry) => {
+    const [entryMethod, template] = entry.split(" ");
+    if (entryMethod === void 0 || template === void 0) return false;
+    return entryMethod === method.toUpperCase() && pathMatches(template, path);
+  });
+  if (matches(KNOWN_PARTNER_ROUTES)) return "known";
+  if (matches(KNOWN_ABSENT_ROUTES)) return "absent";
+  return "unknown";
+}
+var CONTRACT_RETRYABILITY = Object.freeze([
+  Object.freeze({ wireCode: "AccessDeniedException", envelope: "http_envelope", httpStatus: 403, retryable: false }),
+  Object.freeze({ wireCode: "AuthorizationException", envelope: "http_envelope", httpStatus: 401, retryable: false }),
+  Object.freeze({ wireCode: "ConflictException", envelope: "http_envelope", httpStatus: 409, retryable: true }),
+  Object.freeze({ wireCode: "DAILY_QUOTA_EXCEEDED", envelope: "http_envelope", httpStatus: 429, retryable: true }),
+  Object.freeze({ wireCode: "IDEMPOTENCY_KEY_IN_FLIGHT", envelope: "http_envelope", httpStatus: 409, retryable: true }),
+  Object.freeze({ wireCode: "IDEMPOTENCY_KEY_REUSED_DIFFERENT_REQUEST", envelope: "http_envelope", httpStatus: 409, retryable: false }),
+  Object.freeze({ wireCode: "InternalFailureException", envelope: "http_envelope", httpStatus: 500, retryable: true }),
+  Object.freeze({ wireCode: "NotImplementedException", envelope: "http_envelope", httpStatus: 501, retryable: false }),
+  Object.freeze({ wireCode: "PaymentRequiredException", envelope: "http_envelope", httpStatus: 402, retryable: false }),
+  Object.freeze({ wireCode: "ResourceNotFoundException", envelope: "http_envelope", httpStatus: 404, retryable: false }),
+  Object.freeze({ wireCode: "ServiceUnavailableException", envelope: "http_envelope", httpStatus: 503, retryable: true }),
+  Object.freeze({ wireCode: "TIER_UPGRADE_REQUIRED", envelope: "http_envelope", httpStatus: 402, retryable: false }),
+  Object.freeze({ wireCode: "ThrottlingException", envelope: "http_envelope", httpStatus: 429, retryable: true }),
+  Object.freeze({ wireCode: "ValidationException", envelope: "http_envelope", httpStatus: 400, retryable: false }),
+  Object.freeze({ wireCode: "accessDenied", envelope: "http_envelope", httpStatus: 403, retryable: false }),
+  Object.freeze({ wireCode: "authExpired", envelope: "http_envelope", httpStatus: 401, retryable: true }),
+  Object.freeze({ wireCode: "internal_error", envelope: "sse_frame", httpStatus: 200, retryable: false }),
+  Object.freeze({ wireCode: "invalidRequest", envelope: "http_envelope", httpStatus: 400, retryable: false }),
+  Object.freeze({ wireCode: "not_found", envelope: "sse_frame", httpStatus: 200, retryable: false }),
+  Object.freeze({ wireCode: "session_required", envelope: "http_envelope", httpStatus: 403, retryable: false }),
+  Object.freeze({ wireCode: "timeout", envelope: "sse_frame", httpStatus: 200, retryable: true }),
+  Object.freeze({ wireCode: "unavailable", envelope: "http_envelope", httpStatus: 503, retryable: true })
+]);
+Object.freeze(
+  CONTRACT_RETRYABILITY.map((row) => row.wireCode)
+);
+
+// src/client/errors/contract.ts
+var NORMALIZED_FOLD = Object.freeze({
+  // the default status-mapped envelope
+  ValidationException: "validationFailed",
+  AuthorizationException: "authRejected",
+  PaymentRequiredException: "paymentRequired",
+  AccessDeniedException: "accessDenied",
+  ResourceNotFoundException: "resourceNotFound",
+  ConflictException: "conflict",
+  ThrottlingException: "rateLimited",
+  InternalFailureException: "internalError",
+  NotImplementedException: "notImplemented",
+  ServiceUnavailableException: "serviceUnavailable",
+  // dict-detail codes on the widget surface
+  authExpired: "authExpired",
+  unavailable: "serviceUnavailable",
+  session_required: "sessionRequired",
+  accessDenied: "accessDenied",
+  invalidRequest: "sdkUpdateRequired",
+  // typed codes
+  IDEMPOTENCY_KEY_IN_FLIGHT: "idempotencyInFlight",
+  IDEMPOTENCY_KEY_REUSED_DIFFERENT_REQUEST: "idempotencyConflict",
+  DAILY_QUOTA_EXCEEDED: "quotaExceeded",
+  TIER_UPGRADE_REQUIRED: "paymentRequired",
+  // SSE error frames
+  not_found: "conversationNotFound",
+  timeout: "streamTimeout",
+  internal_error: "internalError"
+});
+var CONTRACT_ERROR_ROWS = Object.freeze(
+  CONTRACT_RETRYABILITY.map(
+    (generated) => Object.freeze({
+      wireCode: generated.wireCode,
+      envelope: generated.envelope,
+      retryable: generated.retryable,
+      normalized: NORMALIZED_FOLD[generated.wireCode]
+    })
+  )
+);
+var BY_UPPER = new Map(
+  CONTRACT_ERROR_ROWS.map((r) => [r.wireCode.toUpperCase(), r])
+);
+function contractErrorFor(wireCode) {
+  if (typeof wireCode !== "string") return void 0;
+  const key = wireCode.trim().toUpperCase();
+  return key.length > 0 ? BY_UPPER.get(key) : void 0;
+}
+var CATEGORY_OF = Object.freeze({
+  // the caller's sign-in state is wrong and a credential change is the remedy
+  authExpired: "authentication",
+  authRejected: "authentication",
+  sessionRequired: "authentication",
+  // signed in, correctly identified, and still not allowed
+  accessDenied: "authorization",
+  // a plan gate, not a permission failure: the remedy is commercial
+  paymentRequired: "entitlement",
+  // slow down / come back later
+  quotaExceeded: "rateLimit",
+  rateLimited: "rateLimit",
+  // the request itself was wrong; retrying it unchanged can never succeed
+  validationFailed: "invalidRequest",
+  sdkUpdateRequired: "invalidRequest",
+  // the target is gone, hidden, or was never visible to this caller
+  conversationNotFound: "notFound",
+  petNotFound: "notFound",
+  resourceNotFound: "notFound",
+  // something else already holds the thing
+  conflict: "conflict",
+  idempotencyConflict: "conflict",
+  idempotencyInFlight: "conflict",
+  // the pipe, not the request: timeouts, drops, a briefly unreachable dependency
+  streamTimeout: "connection",
+  streamIncomplete: "connection",
+  upstreamLlmTimeout: "connection",
+  serviceUnavailable: "connection",
+  // the server admits fault
+  internalError: "server",
+  notImplemented: "server",
+  mediaUploadFailed: "media",
+  moderationBlocked: "policy",
+  unknown: "unknown"
+});
+function categoryFor(code) {
+  return CATEGORY_OF[code];
+}
+function fromWire(wire2) {
+  const contractRow = contractErrorFor(wire2);
+  if (contractRow) return contractRow.normalized;
+  const upper = (wire2 ?? "").trim().toUpperCase();
+  const canonical = upper.replace(/[^A-Z0-9]/g, "");
+  if (canonical === "AUTHREJECTED") return "authRejected";
+  if (upper.startsWith("AUTH")) return "authExpired";
+  switch (canonical) {
+    case "DAILYQUOTAEXCEEDED":
+    case "QUOTAEXCEEDED":
+      return "quotaExceeded";
+    case "RATELIMITED":
+    case "TOOMANYREQUESTS":
+      return "rateLimited";
+    case "IDEMPOTENCYKEYCONFLICT":
+    case "IDEMPOTENCYCONFLICT":
+      return "idempotencyConflict";
+    case "ACCESSDENIED":
+    case "FORBIDDEN":
+      return "accessDenied";
+    case "NOTFOUND":
+    case "CONVERSATIONNOTFOUND":
+      return "conversationNotFound";
+    case "PETNOTFOUND":
+      return "petNotFound";
+    case "TIMEOUT":
+    case "STREAMTIMEOUT":
+      return "streamTimeout";
+    // Analysis-domain deterministic 400s (NON-retryable). Additive per SPEC-00 §3.1 / SPEC-11b §2.6:
+    // fold to a NON-retried target so the SDK never retries a permanently-failing bad-input request.
+    // (Comment above the group so the empty fall-through cases stay lint-clean under no-fallthrough.)
+    case "MEDIAUPLOADFAILED":
+    case "UNRECOGNIZEDVIDEOFORMAT":
+    case "FILETOOSMALL":
+      return "mediaUploadFailed";
+    case "MODERATIONBLOCKED":
+      return "moderationBlocked";
+    case "UPSTREAMLLMTIMEOUT":
+      return "upstreamLlmTimeout";
+    case "INTERNALERROR":
+    case "INTERNALSERVERERROR":
+      return "internalError";
+    case "STREAMINCOMPLETE":
+    case "CHATSTREAMINCOMPLETE":
+      return "streamIncomplete";
+    // Deterministic 400s that can only come from an SDK bug -> unknown (NON-retryable). NEVER internalError
+    // (which IS auto-retried): mapping a bad-input 400 to a retryable code retries a request that never succeeds.
+    case "INVALIDANALYSISTYPE":
+    case "INVALIDUPLOADPURPOSE":
+      return "unknown";
+    default:
+      return "unknown";
+  }
+}
+function fromHttpStatus(status) {
+  if (status === 401) return "authExpired";
+  if (status === 403) return "accessDenied";
+  if (status === 404) return "conversationNotFound";
+  if (status === 409) return "idempotencyConflict";
+  if (status === 421) return "unknown";
+  if (status === 429) return "rateLimited";
+  if (status === 400 || status === 422) return "unknown";
+  if (status >= 500) return "internalError";
+  return "unknown";
+}
+var AUTO_RETRYABLE_CODES = /* @__PURE__ */ new Set([
+  "streamTimeout",
+  "rateLimited",
+  "internalError",
+  "upstreamLlmTimeout",
+  "streamIncomplete"
+]);
+function isAutoRetryable(code) {
+  return AUTO_RETRYABLE_CODES.has(code);
+}
+var RETRYABLE_CONTRACT_CODES = /* @__PURE__ */ new Set([
+  "serviceUnavailable",
+  "conflict",
+  "idempotencyInFlight"
+]);
+function isRetryableCode(code) {
+  return isAutoRetryable(code) || RETRYABLE_CONTRACT_CODES.has(code);
+}
+
+// src/client/protocol/frames.ts
+function assertNever(x) {
+  throw new Error(
+    `assertNever: unhandled discriminated-union member ${JSON.stringify(x)}`
+  );
+}
+function acceptedFrame(streamId, lastEventId, serverRequestId = null) {
+  return Object.freeze({ kind: "accepted", streamId, lastEventId, serverRequestId, terminal: false });
+}
+function heartbeatFrame(lastEventId, serverRequestId = null) {
+  return Object.freeze({ kind: "heartbeat", lastEventId, serverRequestId, terminal: false });
+}
+function deltaFrame(delta, lastEventId, serverRequestId = null) {
+  return Object.freeze({ kind: "delta", delta, lastEventId, serverRequestId, terminal: false });
+}
+function doneFrame(fields, serverRequestId = null) {
+  return Object.freeze({
+    kind: "done",
+    terminal: true,
+    conversationId: fields.conversationId,
+    messageId: fields.messageId,
+    title: fields.title,
+    followUpQuestions: Object.freeze([...fields.followUpQuestions]),
+    citations: Object.freeze([...fields.citations]),
+    citationStatus: fields.citationStatus,
+    urgencyLevel: fields.urgencyLevel,
+    urgencyReason: fields.urgencyReason,
+    resultId: fields.resultId,
+    lastEventId: fields.lastEventId,
+    serverRequestId
+  });
+}
+function errorFrame(fields) {
+  return Object.freeze({
+    kind: "error",
+    terminal: true,
+    code: fields.code,
+    retryable: fields.retryable,
+    wireMessage: fields.wireMessage,
+    synthesized: fields.synthesized,
+    lastEventId: fields.lastEventId,
+    serverRequestId: fields.serverRequestId ?? null
+  });
+}
+function analysisStartedFrame(requestId, lastEventId, serverRequestId = null) {
+  return Object.freeze({
+    kind: "analysisStarted",
+    requestId,
+    lastEventId,
+    serverRequestId,
+    terminal: false
+  });
+}
+function analysisCompleteFrame(fields, serverRequestId = null) {
+  return Object.freeze({
+    kind: "analysisComplete",
+    terminal: false,
+    resultId: fields.resultId,
+    analysisType: fields.analysisType,
+    modelVersion: fields.modelVersion,
+    confidence: fields.confidence,
+    detections: Object.freeze([...fields.detections]),
+    interpretation: fields.interpretation,
+    lastEventId: fields.lastEventId,
+    serverRequestId
+  });
+}
+function unknownFrame(raw, lastEventId, serverRequestId = null) {
+  return Object.freeze({
+    kind: "unknown",
+    raw: { ...raw },
+    lastEventId,
+    serverRequestId,
+    terminal: false
+  });
+}
+var BLOCK_SEPARATOR = "\n\n";
+var MAX_PENDING_BLOCK_CHARS = 1048576;
+var wireObjectSchema = zod.z.record(zod.z.string(), zod.z.unknown());
+var URGENCY_LEVELS = ["emergency", "schedule_soon", "home_care"];
+async function* parseSse(bytes, serverRequestId = null) {
+  let resolvedRequestId = null;
+  const requestIdNow = () => {
+    if (resolvedRequestId !== null) return resolvedRequestId;
+    resolvedRequestId = typeof serverRequestId === "function" ? serverRequestId() : serverRequestId;
+    return resolvedRequestId;
+  };
+  const decoder = new TextDecoder("utf-8");
+  let buffer = "";
+  let scanFrom = 0;
+  let sawDelta = false;
+  for await (const chunk of bytes) {
+    buffer += decoder.decode(chunk, { stream: true });
+    for (; ; ) {
+      const sep = buffer.indexOf(BLOCK_SEPARATOR, scanFrom);
+      if (sep === -1) break;
+      const block = buffer.slice(0, sep);
+      buffer = buffer.slice(sep + BLOCK_SEPARATOR.length);
+      scanFrom = 0;
+      const frame = parseBlock(block, requestIdNow());
+      if (frame === null) continue;
+      if (frame.kind === "delta") sawDelta = true;
+      yield frame;
+      if (frame.terminal) return;
+    }
+    scanFrom = buffer.length > 0 ? buffer.length - 1 : 0;
+    if (buffer.length > MAX_PENDING_BLOCK_CHARS) {
+      yield errorFrame({
+        code: sawDelta ? "CHAT_STREAM_INCOMPLETE" : "internal_error",
+        retryable: true,
+        wireMessage: null,
+        synthesized: true,
+        lastEventId: null,
+        serverRequestId: requestIdNow()
+      });
+      return;
+    }
+  }
+  buffer += decoder.decode();
+  if (buffer.trim().length > 0) {
+    const frame = parseBlock(buffer, requestIdNow());
+    if (frame !== null) {
+      if (frame.kind === "delta") sawDelta = true;
+      yield frame;
+      if (frame.terminal) return;
+    }
+  }
+  yield errorFrame({
+    code: sawDelta ? "CHAT_STREAM_INCOMPLETE" : "internal_error",
+    retryable: true,
+    wireMessage: null,
+    synthesized: true,
+    lastEventId: null,
+    serverRequestId: requestIdNow()
+  });
+}
+function parseBlock(block, serverRequestId) {
+  let id = null;
+  const dataLines = [];
+  for (const rawLine of block.split("\n")) {
+    const line = rawLine.replace(/\s+$/, "");
+    if (line.length === 0 || line.startsWith(":")) continue;
+    if (line.startsWith("id:")) {
+      id = line.slice(3).trim();
+    } else if (line.startsWith("data:")) {
+      dataLines.push(line.slice(5).replace(/^ /, ""));
+    }
+  }
+  if (dataLines.length === 0) return null;
+  let decoded;
+  try {
+    decoded = JSON.parse(dataLines.join("\n"));
+  } catch {
+    return null;
+  }
+  if (typeof decoded !== "object" || decoded === null || Array.isArray(decoded)) return null;
+  const parsed = wireObjectSchema.safeParse(decoded);
+  if (!parsed.success) return null;
+  return frameFromWire(parsed.data, id, serverRequestId);
+}
+function frameFromWire(json, lastEventId, serverRequestId) {
+  const type = json["type"];
+  const event = json["event"];
+  if (type === "error" || "error" in json) {
+    return errorFrame({
+      code: asString(json["code"]) ?? "unknown",
+      retryable: json["retryable"] === true,
+      wireMessage: asString(json["error"]),
+      synthesized: false,
+      lastEventId,
+      serverRequestId
+    });
+  }
+  if (type === "done" || json["done"] === true) {
+    return doneFrame({
+      conversationId: asString(json["conversation_id"]) ?? "",
+      messageId: asString(json["message_id"]),
+      title: asString(json["title"]),
+      followUpQuestions: asStringList(json["follow_up_questions"]),
+      citations: asMapList(json["citations"]),
+      citationStatus: asString(json["citation_status"]),
+      urgencyLevel: asUrgency(json["urgency_level"]),
+      urgencyReason: asString(json["urgency_reason"]),
+      resultId: asString(json["result_id"]),
+      lastEventId
+    }, serverRequestId);
+  }
+  if (type === "accepted" || json["status"] === "reasoning") {
+    return acceptedFrame(asString(json["stream_id"]), lastEventId, serverRequestId);
+  }
+  if (type === "heartbeat" || json["heartbeat"] === true) {
+    return heartbeatFrame(lastEventId, serverRequestId);
+  }
+  if (type === "text.delta" || "delta" in json || "token" in json) {
+    const delta = asString(json["delta"]) ?? asString(json["token"]) ?? "";
+    return deltaFrame(delta, lastEventId, serverRequestId);
+  }
+  if (event === "analysis_started") {
+    return analysisStartedFrame(asString(json["request_id"]), lastEventId, serverRequestId);
+  }
+  if (event === "analysis_complete") {
+    return analysisCompleteFrame({
+      resultId: asString(json["result_id"]),
+      analysisType: asString(json["analysis_type"]),
+      modelVersion: asString(json["model_version"]),
+      confidence: asNumber(json["confidence"]),
+      detections: asMapList(json["detections"]),
+      interpretation: asString(json["interpretation"]),
+      lastEventId
+    }, serverRequestId);
+  }
+  return unknownFrame(json, lastEventId, serverRequestId);
+}
+function asString(v) {
+  return typeof v === "string" ? v : null;
+}
+function asNumber(v) {
+  return typeof v === "number" && Number.isFinite(v) ? v : null;
+}
+function asUrgency(v) {
+  return typeof v === "string" && URGENCY_LEVELS.includes(v) ? v : null;
+}
+function asStringList(v) {
+  if (!Array.isArray(v)) return [];
+  return v.map((e) => typeof e === "string" ? e : String(e));
+}
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v);
+}
+function asMapList(v) {
+  if (!Array.isArray(v)) return [];
+  return v.filter(isPlainObject);
+}
+
+// src/client/errors/EverfurError.ts
+var USER_FACING_COPY = Object.freeze({
+  authExpired: "Please sign in again to continue.",
+  authRejected: "Please sign in again to continue.",
+  sessionRequired: "This app needs to be updated to keep using Everfur.",
+  accessDenied: "This feature isn't available on your account right now.",
+  paymentRequired: "This is part of a paid plan.",
+  quotaExceeded: "You have used today's messages. This resets tomorrow.",
+  rateLimited: "You are sending messages quickly. Try again in a few seconds.",
+  validationFailed: "Something in that request was not right. Check the details and try again.",
+  sdkUpdateRequired: "This app needs to be updated to keep using Everfur.",
+  conflict: "That is already running. Wait for it to finish, then try again.",
+  idempotencyConflict: "That message was already delivered.",
+  idempotencyInFlight: "That is still processing. Give it a moment.",
+  conversationNotFound: "This conversation is no longer available.",
+  petNotFound: "We could not find that pet. Please pick a pet and try again.",
+  resourceNotFound: "We could not find that.",
+  streamTimeout: "The response timed out. Tap retry to try again.",
+  mediaUploadFailed: "We could not upload that photo. Please attach it again.",
+  moderationBlocked: "This request cannot be answered here.",
+  upstreamLlmTimeout: "The response timed out. Tap retry to try again.",
+  internalError: "We hit a snag on our end. Please try again.",
+  notImplemented: "That is not available yet.",
+  serviceUnavailable: "That service is briefly unavailable. Try again shortly.",
+  streamIncomplete: "The connection dropped mid-answer. Tap retry to continue.",
+  unknown: "Something went wrong. Please try again."
+});
+function userFacingError(code) {
+  return USER_FACING_COPY[code];
+}
+function defineHidden(target, key, value) {
+  Object.defineProperty(target, key, {
+    value,
+    enumerable: false,
+    writable: false,
+    configurable: false
+  });
+}
+function makeEverfurError(code, opts) {
+  contractErrorFor(opts?.wireCode);
+  const error = {
+    code,
+    category: categoryFor(code),
+    retryable: opts?.retryable ?? isRetryableCode(code),
+    displayMessage: userFacingError(code)
+  };
+  if (opts?.httpStatus !== void 0) error.httpStatus = opts.httpStatus;
+  if (opts?.requestId) error.requestId = opts.requestId;
+  if (opts?.wireMessage) defineHidden(error, "wireMessage", opts.wireMessage);
+  if (opts?.raw !== void 0 && opts.raw !== null) defineHidden(error, "raw", opts.raw);
+  return Object.freeze(error);
+}
+
+// src/client/transport.ts
+async function* bufferedTextByteSource(text, splitAt = []) {
+  const bytes = new TextEncoder().encode(text);
+  const points = [...new Set(splitAt)].filter((n) => n > 0 && n < bytes.length).sort((a, b) => a - b);
+  let start = 0;
+  for (const point of points) {
+    yield bytes.subarray(start, point);
+    start = point;
+  }
+  yield bytes.subarray(start);
+}
+function errorFromResponse(status, body, requestId) {
+  const wireCode = extractWireCode(body);
+  const code = wireCode ? fromWire(wireCode) : fromHttpStatus(status);
+  const wireMessage = extractWireMessage(body);
+  return makeEverfurError(code, {
+    httpStatus: status,
+    ...extractRetryable(body) ? { retryable: true } : {},
+    ...{},
+    ...wireCode ? { wireCode } : {},
+    ...wireMessage ? { wireMessage } : {},
+    ...body !== null && body !== void 0 ? { raw: body } : {}
+  });
+}
+function extractWireCode(body) {
+  const b = body;
+  const code = b?.error?.code ?? b?.code;
+  return typeof code === "string" && code.length > 0 ? code : null;
+}
+function extractWireMessage(body) {
+  const b = body;
+  const message = b?.error?.message ?? b?.message;
+  return typeof message === "string" && message.length > 0 ? message : null;
+}
+function extractRetryable(body) {
+  const b = body;
+  return b?.error?.retryable === true || b?.retryable === true;
+}
+
+// src/core/testing/MockTransport.ts
+var wire = Object.freeze({
+  accepted: (streamId) => JSON.stringify(streamId ? { type: "accepted", stream_id: streamId } : { type: "accepted" }),
+  heartbeat: () => JSON.stringify({ type: "heartbeat" }),
+  delta: (text) => JSON.stringify({ type: "text.delta", delta: text }),
+  done: (fields) => JSON.stringify({ type: "done", ...fields ?? {} }),
+  error: (code, retryable = false) => JSON.stringify({ type: "error", code, retryable })
+});
+function assertRouteIsServed(method, path) {
+  const verdict = classifyRoute(method, path);
+  if (verdict === "known") return;
+  if (verdict === "absent") {
+    throw new EverfurConfigError(
+      "invalid-argument",
+      `MockTransport: ${method} ${path} is a route the Everfur backend does NOT serve, so this call returns 404 in production. Scripting a success for it makes a green test that hides a broken integration. Known-absent routes: ${KNOWN_ABSENT_ROUTES.join(", ")}. Pass { strictPaths: false } to MockTransport only if you are deliberately testing this shape.`
+    );
+  }
+  throw new EverfurConfigError(
+    "invalid-argument",
+    `MockTransport: ${method} ${path} is not a known partner-plane route. If the backend has gained it, add it to KNOWN_PARTNER_ROUTES in src/core/testing/knownRoutes.ts. Pass { strictPaths: false } to opt out for this transport.`
+  );
+}
+var MockTransport = class {
+  constructor(options = {}) {
+    this.streamQueue = [];
+    this.requestQueue = [];
+    /** The last script dequeued, replayed once the queue drains. See `request` for why. */
+    /**
+     * The last scripted response, KEYED BY ENDPOINT.
+     *
+     * It used to be a single field, so a `enqueueRequest({ status: 500 })` scripted for one endpoint kept
+     * replaying for every OTHER endpoint once the queue drained — the comment below says the fallback means
+     * "this endpoint is down", and a global field cannot mean that. A fault leaked across endpoints and a
+     * test could assert an outcome the SDK would never produce.
+     */
+    this.lastRequestScript = /* @__PURE__ */ new Map();
+    this.openCount = 0;
+    this.requests = [];
+    this.streamRequests = [];
+    /** Peak concurrent open streams observed (bulkhead assertions). */
+    this.peak = 0;
+    this.strictPaths = options.strictPaths ?? true;
+  }
+  /** Live count of streams that have opened but not yet torn down. MUST return to 0 after a cancel. */
+  get openStreams() {
+    return this.openCount;
+  }
+  get peakOpenStreams() {
+    return this.peak;
+  }
+  enqueueStream(...scripts) {
+    this.streamQueue.push(...scripts);
+    return this;
+  }
+  enqueueRequest(...scripts) {
+    this.requestQueue.push(...scripts);
+    return this;
+  }
+  async request(req) {
+    if (this.strictPaths) assertRouteIsServed(req.method, req.path);
+    const base = {
+      method: req.method,
+      path: req.path,
+      headers: { ...req.headers ?? {} },
+      ...req.query === void 0 ? {} : { query: { ...req.query } }
+    };
+    const record = req.body === void 0 ? base : { ...base, body: req.body };
+    this.requests.push(record);
+    const endpoint = `${req.method} ${req.path}`;
+    const next = this.requestQueue.shift();
+    if (next !== void 0) this.lastRequestScript.set(endpoint, next);
+    const script = next ?? this.lastRequestScript.get(endpoint) ?? { status: 200, body: {} };
+    const status = script.status ?? 200;
+    if (status === 304 || status >= 400) {
+      return err(errorFromResponse(status, script.body ?? null));
+    }
+    return ok(script.body ?? {});
+  }
+  stream(req, signal) {
+    if (this.strictPaths) assertRouteIsServed(req.method, req.path);
+    this.streamRequests.push({
+      path: req.path,
+      authorization: header(req, "authorization"),
+      partnerKey: header(req, "x-everfur-partner-key"),
+      idempotencyKey: header(req, "idempotency-key"),
+      ...req.body === void 0 ? {} : { body: req.body },
+      headers: { ...req.headers ?? {} }
+    });
+    const script = this.streamQueue.shift() ?? { kind: "sse", blocks: [wire.done()] };
+    return this.openStream(script, signal);
+  }
+  async *openStream(script, signal) {
+    this.openCount += 1;
+    if (this.openCount > this.peak) this.peak = this.openCount;
+    try {
+      yield* this.runScript(script, signal);
+    } finally {
+      this.openCount -= 1;
+    }
+  }
+  async *runScript(script, signal) {
+    switch (script.kind) {
+      case "httpError": {
+        const wireCode = extractWireCode2(script.body) ?? statusToWireCode(script.status);
+        yield errorFrame({
+          code: wireCode,
+          retryable: extractRetryable2(script.body) || isAutoRetryable(fromWire(wireCode)),
+          wireMessage: extractWireMessage2(script.body),
+          synthesized: true,
+          lastEventId: null
+        });
+        return;
+      }
+      case "network":
+        yield errorFrame({
+          code: "INTERNAL_ERROR",
+          retryable: true,
+          wireMessage: "network request failed",
+          synthesized: true,
+          lastEventId: null
+        });
+        return;
+      case "partialByte":
+        yield* parseSse(bufferedTextByteSource(script.body, script.splitAt));
+        return;
+      case "sse":
+        yield* parseSse(sseByteSource(script.blocks, script.gapMs ?? 0, signal));
+        return;
+      case "drop":
+        yield* parseSse(sseByteSource(script.blocks, 0, signal));
+        return;
+      case "stall":
+        yield* parseSse(stallByteSource(script.preface ?? [], signal));
+        return;
+      default:
+        return assertNever(script);
+    }
+  }
+};
+async function* sseByteSource(blocks, gapMs, signal) {
+  const enc = new TextEncoder();
+  let first = true;
+  for (const block of blocks) {
+    if (signal.aborted) return;
+    if (!first && gapMs > 0) {
+      const outcome = await abortableSleep(gapMs, signal);
+      if (outcome === "abort") return;
+    }
+    first = false;
+    yield enc.encode(toSseBlock(block));
+  }
+}
+async function* stallByteSource(preface, signal) {
+  const enc = new TextEncoder();
+  for (const block of preface) {
+    if (signal.aborted) return;
+    yield enc.encode(toSseBlock(block));
+  }
+  await abortableSleep(Infinity, signal);
+}
+function toSseBlock(payload) {
+  return `data: ${payload}
+
+`;
+}
+function abortableSleep(ms, signal) {
+  return new Promise((resolve) => {
+    if (signal.aborted) {
+      resolve("abort");
+      return;
+    }
+    let handle = null;
+    const onAbort = () => {
+      if (handle !== null) clearTimeout(handle);
+      signal.removeEventListener("abort", onAbort);
+      resolve("abort");
+    };
+    if (Number.isFinite(ms)) {
+      handle = setTimeout(() => {
+        signal.removeEventListener("abort", onAbort);
+        resolve("timeout");
+      }, ms);
+    }
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+function header(req, name) {
+  const headers = req.headers;
+  if (!headers) return null;
+  for (const [key, value] of Object.entries(headers)) {
+    if (key.toLowerCase() === name) return value;
+  }
+  return null;
+}
+function extractWireCode2(body) {
+  const b = body;
+  const code = b?.error?.code ?? b?.code;
+  return typeof code === "string" && code.length > 0 ? code : null;
+}
+function extractWireMessage2(body) {
+  const b = body;
+  const message = b?.error?.message ?? b?.message;
+  return typeof message === "string" && message.length > 0 ? message : null;
+}
+function extractRetryable2(body) {
+  const b = body;
+  return b?.error?.retryable === true || b?.retryable === true;
+}
+function statusToWireCode(status) {
+  if (status === 401) return "AUTH_EXPIRED";
+  if (status === 403) return "ACCESS_DENIED";
+  if (status === 404) return "NOT_FOUND";
+  if (status === 409) return "IDEMPOTENCY_CONFLICT";
+  if (status === 421) return "MISDIRECTED_REQUEST";
+  if (status === 429) return "RATE_LIMITED";
+  if (status === 400 || status === 422) return "INVALID_REQUEST";
+  if (status >= 500) return "INTERNAL_ERROR";
+  return "";
+}
+
+exports.MockTransport = MockTransport;
+exports.wire = wire;