@volter/live 0.5.212 → 0.5.213

package/src/asset-library.ts

@@ -0,0 +1,104 @@
+/**
+ * THE ASSET LIBRARY, as the session's `/__editor/asset-library/*` routes answer it (editor-core's
+ * `server/asset-library-routes.ts`, which takes these shapes from here): search a source, list an asset's files, and
+ * download one into the project. `editor.assetLibrary` reaches it through `EditorClient`, so a request carries the
+ * session's connection token as every other one does.
+ */
+import type { EditorClient } from './client.js';
+
+/** An asset as a search answers it. */
+export interface OnlineAsset {
+  id: string;
+  source: 'polyhaven' | 'ambientcg' | 'local';
+  name: string;
+  type: 'model' | 'animation' | 'source' | 'hdri' | 'texture' | 'material';
+  thumbnailUrl: string;
+  categories: string[];
+  tags: string[];
+  downloadCount?: number;
+  license?: string;
+  author?: string;
+  sourceUrl?: string;
+  cloudHosted?: boolean;
+  variantId?: string;
+  variantCount?: number;
+  sizeBytes?: number;
+  animationCount?: number;
+  deliveryKinds?: ('local-ssd' | 'cloud' | 'remote')[];
+  addedAt?: string;
+  capabilities?: {
+    previewable: boolean;
+    importable: boolean;
+    runtimeReady: boolean;
+    animated: boolean;
+    deliveryAvailable: boolean;
+    health: 'healthy' | 'source-only' | 'unsupported';
+  };
+}
+
+/** One file of an asset that can be downloaded (`files`); `download` takes it with the asset. */
+export interface AssetFileOption {
+  label: string;
+  format: string;
+  url: string;
+  sizeBytes?: number;
+  /** Additional files that must be downloaded alongside the main URL (GLTF includes). */
+  includes?: { relativePath: string; url: string; size: number }[];
+}
+
+/** `GET /search`'s query. `type` is the kind the source names (`model`, `hdri`, …; `all` in the local catalog). */
+export interface AssetSearchQuery {
+  source: OnlineAsset['source'];
+  type: string;
+  q?: string;
+  category?: string;
+  offset?: number;
+  limit?: number;
+}
+
+/** `POST /download`'s body: the asset and the file `files` offered for it. `license` is the search result's, which the
+ *  route records for a remote source; the local catalog's own license is recorded whatever is passed. */
+export interface AssetDownloadRequest {
+  source: OnlineAsset['source'];
+  id: string;
+  name: string;
+  url: string;
+  format: string;
+  includes?: AssetFileOption['includes'];
+  license?: string;
+}
+
+/** What a download answers: the file's path under the project's `public/`, the provenance operation that wrote it, and
+ *  `ledgerError` when the asset and its license could not be recorded in `.volter/assets.json`. */
+export interface AssetDownloadResult {
+  ok: true;
+  path: string;
+  provenanceOperationId?: string;
+  ledgerError?: string;
+  alreadyExists?: boolean;
+}
+
+/** `editor.assetLibrary`: the routes, one call each. */
+export class LiveAssetLibrary {
+  readonly #client: EditorClient;
+
+  constructor(client: EditorClient) {
+    this.#client = client;
+  }
+
+  /** Search one source: `{ assets, total }`, each asset with its tags, license, author and source address. */
+  async search(query: AssetSearchQuery): Promise<{ assets: OnlineAsset[]; total: number }> {
+    return this.#client.assetLibraryRequest('GET', 'search', query);
+  }
+
+  /** The files an asset can be downloaded as. */
+  async files(asset: { source: OnlineAsset['source']; id: string }): Promise<{ files: AssetFileOption[] }> {
+    return this.#client.assetLibraryRequest('GET', 'files', asset);
+  }
+
+  /** Download one file of an asset into the project's `public/asset-library/`, recording the asset and its license in
+   *  the project's `.volter/assets.json`. */
+  async download(request: AssetDownloadRequest): Promise<AssetDownloadResult> {
+    return this.#client.assetLibraryRequest('POST', 'download', request);
+  }
+}

package/src/client.ts

@@ -1,5 +1,6 @@
 import type { Dispatcher } from 'undici';
 import { createDispatcher, dispatchFetch } from './http-transport.js';
+import { refuseWithoutRegisteredToken, withSessionToken } from './registry-format.js';
 import { verbCommandId } from '@volter/sdk/commands';
 import type { DocumentProbeResult, DocumentProbeStep } from '@volter/sdk/document-probe';
 import type {
@@ -232,7 +233,7 @@ export class EditorClient {
         commandDispatcher = deadlineMs > UNDICI_DEFAULT_HEADERS_TIMEOUT_MS
           ? createDispatcher(deadlineMs + 30_000)
           : undefined;
-        res = this.fetchOverride ? await this.fetchOverride(url, init) : await dispatchFetch(url, init, commandDispatcher);
+        res = this.fetchOverride ? await this.fetchOverride(url, init) : await dispatchFetch(url, withSessionToken(url, init), commandDispatcher);
         break;
       } catch (error) {
         await commandDispatcher?.destroy();
@@ -270,6 +271,14 @@ export class EditorClient {
         );
       }
     }
+    if (!this.fetchOverride) {
+      try {
+        refuseWithoutRegisteredToken(url, res.status);
+      } catch (error) {
+        await commandDispatcher?.destroy();
+        throw error;
+      }
+    }
     let data: { ok: boolean; error?: string; code?: string } & T;
     try {
       data = (await this.readJson(res)) as typeof data;
@@ -512,11 +521,11 @@ export class EditorClient {
   }
 
   /** Switch the editor's NAMED WORKSPACE — the task-named layout memory
-   *  (`design`/`animate`/`look`, or one a package contributes). Resolves once the
-   *  dock has finished rebuilding, so a following capture photographs the
-   *  arrangement that was asked for. */
-  async setWorkspace(workspace: EditorWorkspaceName): Promise<void> {
-    await this.command({ type: 'set-workspace', workspace });
+   *  (`design`/`animate`/`look`, or one a package contributes). Answers the workspace now active and whether its dock
+   *  had rebuilt within the command's wait (`applied`): when it had, a following capture photographs the arrangement
+   *  that was asked for. */
+  async setWorkspace(workspace: EditorWorkspaceName): Promise<{ readonly workspace: EditorWorkspaceName; readonly applied: boolean }> {
+    return this.command<{ workspace: EditorWorkspaceName; applied: boolean }>({ type: 'set-workspace', workspace });
   }
 
   /** Choose a STYLE (`volter.style`) — its material, icon set and type, and the colour theme it
@@ -873,6 +882,34 @@ export class EditorClient {
     return data.project;
   }
 
+  /** One `/__editor/asset-library/<route>` request, for `editor.assetLibrary` (`asset-library.ts`): a GET's fields as
+   *  its query, a POST's as its JSON body. A refusal throws the route's own error. */
+  async assetLibraryRequest<T>(method: 'GET' | 'POST', route: string, fields: object): Promise<T> {
+    const url = new URL(`${this.baseUrl}/__editor/asset-library/${route}`);
+    if (method === 'GET') {
+      for (const [name, value] of Object.entries(fields)) if (value !== undefined) url.searchParams.set(name, String(value));
+    }
+    // A DOWNLOAD WAITS AS LONG AS THE ROUTE DOES. It answers once the whole file is in the project, and it cancels the
+    // import when its caller goes (`res.once('close')` in the route), so undici's default 300 s headers deadline would
+    // cancel a large asset on a slow link. Like a command whose budget passes that default (`command`), it gets its
+    // own dispatcher, here with no deadline at all (undici sets no timer for 0, `client-h1.js` `setTimeout`): the
+    // route sets none. A search or a file listing is one upstream lookup whose route cancels nothing, and keeps the
+    // default as its ceiling.
+    const dispatcher = route === 'download' ? createDispatcher(0) : undefined;
+    try {
+      const res = await this.httpFetch(
+        url.toString(),
+        method === 'GET' ? undefined : { method, headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(fields) },
+        dispatcher,
+      );
+      const data = (await this.readJson(res)) as T & { error?: string };
+      if (!res.ok) throw new Error(data.error ?? `${method} /__editor/asset-library/${route} failed: ${res.status}`);
+      return data;
+    } finally {
+      await dispatcher?.destroy();
+    }
+  }
+
   async listRecentProjects(): Promise<RecentProject[]> {
     const res = await this.httpFetch(`${this.baseUrl}/__editor/recent-projects`);
     const data = (await this.readJson(res)) as { projects: RecentProject[]; error?: string };
@@ -987,9 +1024,11 @@ export class EditorClient {
   private async httpFetch(
     url: string,
     init?: RequestInit,
+    dispatcher?: Dispatcher,
   ): Promise<Response> {
+    let res: Response;
     try {
-      return this.fetchOverride ? await this.fetchOverride(url, init) : await dispatchFetch(url, init);
+      res = this.fetchOverride ? await this.fetchOverride(url, init) : await dispatchFetch(url, withSessionToken(url, init), dispatcher);
     } catch (error) {
       if ((error as { name?: string } | null)?.name === 'TimeoutError') throw error;
       const { code, detail } = describeFetchFailure(error);
@@ -1000,6 +1039,8 @@ export class EditorClient {
         code,
       );
     }
+    if (!this.fetchOverride) refuseWithoutRegisteredToken(url, res.status);
+    return res;
   }
 
   /** Require a JSON response from the editor server. */

package/src/discovery.ts

@@ -1,5 +1,5 @@
 /** Registered-session discovery; never selects another project's session. */
-import { readLiveRegisteredSessions, servedProjectAnswer } from './registry-format.js';
+import { readLiveRegisteredSessions, servedProjectAnswer, sessionFetch } from './registry-format.js';
 export { servedProjectAnswer } from './registry-format.js';
 
 export const EDITOR_SESSION_DISCOVERY_TIMEOUT_MS = 2000;
@@ -50,7 +50,7 @@ export interface EditorSessionInfo {
 }
 
 async function fetchJson(url: string, timeoutMs: number): Promise<unknown> {
-  const res = await fetch(url, { signal: AbortSignal.timeout(timeoutMs) });
+  const res = await sessionFetch(url, { signal: AbortSignal.timeout(timeoutMs) });
   if (!res.ok) throw new Error(`GET /__editor/project returned HTTP ${res.status}`);
   return await res.json();
 }

package/src/editor.ts

@@ -29,6 +29,7 @@ import type {
   ViewportCapture,
 } from '@volter/sdk';
 import type { EditorClient, HistoryStep, OpenedDocument } from './client.js';
+import { LiveAssetLibrary } from './asset-library.js';
 import { LiveEditorDocument } from './editor-document.js';
 
 /** A panel `showPanel` can focus: the console, the build surface, or any key
@@ -97,9 +98,14 @@ export class LiveEditor {
    * See `@volter/sdk`'s editor-document-probe for scope and gesture contracts. */
   readonly document: LiveEditorDocument;
 
+  /** The asset library: search a source, list an asset's files, download one into the project with its license
+   *  recorded (`asset-library.ts`). */
+  readonly assetLibrary: LiveAssetLibrary;
+
   constructor(client: EditorClient) {
     this.#client = client;
     this.document = new LiveEditorDocument(client);
+    this.assetLibrary = new LiveAssetLibrary(client);
   }
 
   /** A verb a composed package contributes (`<package>-<verb>`), waited on for its own row's budget. */
@@ -272,8 +278,8 @@ export class LiveEditor {
   }
 
 
-  async workspace(id: EditorWorkspaceName): Promise<void> {
-    await this.#client.setWorkspace(id);
+  async workspace(id: EditorWorkspaceName): Promise<{ readonly workspace: EditorWorkspaceName; readonly applied: boolean }> {
+    return this.#client.setWorkspace(id);
   }
 
   /**
@@ -521,7 +527,9 @@ export class LiveEditor {
     return this.#client.removeInspectionField(path);
   }
 
-  /** Open a document by its adapter-declared id, through its registered owner. */
+  /** Open a document by its adapter-declared id, through its registered owner. An id the adapter would list for a
+   *  file not written yet (a new model, `model:prefabs/coin/coin.blend`) opens as that new document, written by its
+   *  first save. */
   async open(id: string): Promise<OpenedDocument> {
     return this.#client.open(id);
   }

package/src/index.ts

@@ -8,10 +8,11 @@ import { editorMemberHint } from './member-hints.js';
 
 export { LiveEditor, inferAssetKind, type PanelName } from './editor.js';
 export { LiveEditorDocument } from './editor-document.js';
+export type { AssetDownloadRequest, AssetDownloadResult, AssetFileOption, AssetSearchQuery, OnlineAsset } from './asset-library.js';
 export type { DocumentGestureOptions, DocumentKeyOptions, DocumentPasteOptions } from './editor-document.js';
 export { editorMemberHint, withEditorMemberHints } from './member-hints.js';
 export { resolveSession, findProjectRootFrom, NO_SESSION_FOR_PROJECT, SESSION_MANIFEST_UNREADABLE } from './session.js';
-export type { ResolvedSession, SessionResolutionDeps, SessionListingTransport, ProjectSessionHint } from './session.js';
+export type { ResolvedSession, SessionResolutionDeps, SessionListingTransport } from './session.js';
 export type { ActiveDocumentCapture, EditorView, PresentedEditorView } from '@volter/sdk';
 
 export interface LiveBindings {

package/src/product-locator.ts

@@ -54,8 +54,8 @@ export interface ProductIdentity {
   readonly entry: string;
   /**
    * The packages this product mounts, in order — `contributes.volter.product.composes`. The ONE statement of
-   * the composition: the build serves it to the entry as `volter:composition`, and the session
-   * reads it here for the catalog and the serving doors.
+   * the composition: the session reads it here for the packages it installs and serves, the catalog and the
+   * serving doors.
    */
   readonly composes: readonly string[];
 

package/src/registry-format.ts

@@ -2,6 +2,11 @@
  * Shared editor-session registry format: entry shape, guards, path,
  * liveness-filtered reads, served-project parsing and pending launches.
  * The server’s session-registry module owns writes to this format.
+ *
+ * The registry is also the CREDENTIAL FILE for the owner's own processes: each entry carries its session's
+ * connection token, and `sessionFetch` is how a process on this machine reaches a session with it, as a Code-OSS
+ * client reads its server's `--connection-token-file` (`src/vs/server/node/serverConnectionToken.ts:62-79` in the
+ * `volter-ai/code-oss` fork). The file is the user's alone (0600, written by the session).
  */
 
 import {
@@ -26,9 +31,9 @@ export interface EditorSessionEntry {
   /** ISO timestamp of server start. */
   startedAt: string;
   sessionId: string | null;
-  /** Private loopback control credential — never returned by an editor HTTP
-   *  route; exists only in this user-private registry. */
-  controlSecret?: string | null;
+  /** The session's connection token, which every request to it carries (`sessionFetch`). Never returned by a
+   *  session route; it is in this user-private file and in the page's cookie. */
+  connectionToken?: string | null;
   repositoryId: string | null;
   worktreeId: string | null;
   worktreeRoot: string | null;
@@ -51,7 +56,7 @@ export function isEditorSessionEntry(v: unknown): v is EditorSessionEntry {
     typeof s['pid'] === 'number' &&
     typeof s['startedAt'] === 'string' &&
     optionalIdentity(s['sessionId']) &&
-    optionalIdentity(s['controlSecret']) &&
+    optionalIdentity(s['connectionToken']) &&
     optionalIdentity(s['repositoryId']) &&
     optionalIdentity(s['worktreeId']) &&
     optionalIdentity(s['worktreeRoot']) &&
@@ -66,7 +71,7 @@ export function normalizeEditorSessionEntry(session: EditorSessionEntry): Editor
   return {
     ...session,
     sessionId: session.sessionId ?? null,
-    controlSecret: session.controlSecret ?? null,
+    connectionToken: session.connectionToken ?? null,
     repositoryId: session.repositoryId ?? null,
     worktreeId: session.worktreeId ?? null,
     worktreeRoot: session.worktreeRoot ?? null,
@@ -102,6 +107,64 @@ export function readLiveRegisteredSessions(): EditorSessionEntry[] {
   }
 }
 
+/**
+ * The cookie the session reads its connection token from: Code-OSS's own (`connectionTokenCookieName`,
+ * `src/vs/base/common/network.ts:187`). The page's Code-OSS server sets it on the page's host from the address's
+ * `?tkn=` (`src/vs/server/node/webClientServer.ts:313-336`), and the session's routes share that host through its
+ * proxy and the token through the project's token file, so one cookie carries both.
+ */
+export const CONNECTION_TOKEN_COOKIE = 'vscode-tkn';
+
+/** The connection token of the live session listening on `port` of this machine, from its entry; null when no live
+ *  session there registered one. */
+export function registeredConnectionToken(port: number): string | null {
+  return readLiveRegisteredSessions().find((session) => session.port === port)?.connectionToken ?? null;
+}
+
+const LOOPBACK_HOSTS = new Set(['127.0.0.1', 'localhost', '[::1]']);
+
+/** The port of a session `url` names on this machine, or null for any other address. */
+function loopbackSessionPort(url: string | URL): number | null {
+  const target = new URL(url);
+  return target.protocol === 'http:' && LOOPBACK_HOSTS.has(target.hostname) && target.port !== '' ? Number(target.port) : null;
+}
+
+/** `init` with the connection token of the session `url` names, as the cookie the session reads. Only a loopback
+ *  address gets one, and only a registered session's: the token never leaves this machine. */
+export function withSessionToken(url: string | URL, init: RequestInit = {}): RequestInit {
+  const port = loopbackSessionPort(url);
+  const token = port === null ? null : registeredConnectionToken(port);
+  if (token === null) return init;
+  const headers = new Headers(init.headers);
+  headers.set('cookie', `${CONNECTION_TOKEN_COOKIE}=${token}`);
+  return { ...init, headers };
+}
+
+/**
+ * Say why a session on this machine refused (403) a request this process could send it no token with: its registry
+ * entry, the one place the owner's processes read the token from, is missing or carries none. Throws that; returns
+ * when the refusal is something else (a token was sent, or the address is not a local session's).
+ */
+export function refuseWithoutRegisteredToken(url: string | URL, status: number): void {
+  if (status !== 403) return;
+  const port = loopbackSessionPort(url);
+  if (port === null || registeredConnectionToken(port) !== null) return;
+  throw new Error(
+    `The editor session on port ${port} refused this request: its connection token could not be read, because the ` +
+      `session registry ${EDITOR_SESSIONS_REGISTRY_FILE} has no live entry for port ${port} carrying one. The session ` +
+      "says why its entry could not be written in its terminal and on its console, and writes it again every minute.",
+  );
+}
+
+/** `fetch` to a session on this machine, carrying its connection token (`withSessionToken`). Every request a process
+ *  of the owner's makes to a session goes through here or through `EditorClient`, which does the same, and a refusal
+ *  for want of the token says so (`refuseWithoutRegisteredToken`). */
+export async function sessionFetch(url: string | URL, init?: RequestInit): Promise<Response> {
+  const response = await fetch(url, withSessionToken(url, init));
+  refuseWithoutRegisteredToken(url, response.status);
+  return response;
+}
+
 /** Announce a launch before the server can register. Each launcher owns its file. */
 export function announceEditorLaunch(project: string): () => void {
   const directory = join(project, '.volter', 'editor-launches');

package/src/session.ts

@@ -1,9 +1,8 @@
-/** Resolve an existing session for exactly one project.
- * Prefer the project's hint, verify it against the served canonical path,
- * then consult the shared registry. Never fall back to another project. */
+/** Resolve an existing session for exactly one project, from the shared registry.
+ * Never fall back to another project. */
 
-import { existsSync, readFileSync, realpathSync, statSync } from 'node:fs';
-import { dirname, join, resolve } from 'node:path';
+import { existsSync, realpathSync, statSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
 import { resolveManifestPath } from '@volter/project/manifest/locate';
 import { resolveProductForProject } from './product-locator.js';
 import {
@@ -11,7 +10,6 @@ import {
   type EditorSessionInfo,
   type SessionListingTransport as SessionDiscoveryTransport,
   HttpSessionDiscovery,
-  servedProjectAnswer,
   withTimeout,
 } from './discovery.js';
 
@@ -41,17 +39,6 @@ export interface SessionResolutionDeps {
   transport?: SessionListingTransport;
   /** Project-root discovery — defaults to the real fs walk (`findProjectRootFrom` above). Overridable for tests. */
   findProjectRootFrom?: (dir: string) => string | null;
-  /** Project-local session hint reader. Defaults to `.volter/session.json`. */
-  readProjectSession?: (projectRoot: string) => ProjectSessionHint | null;
-  /** Exact-session verifier. Defaults to GET /__editor/project + canonical project matching. */
-  verifyProjectSession?: (hint: ProjectSessionHint, projectRoot: string) => Promise<boolean>;
-}
-
-export interface ProjectSessionHint {
-  port: number;
-  pid: number;
-  url: string;
-  startedAt: string;
 }
 
 function canonicalPath(path: string): string {
@@ -80,49 +67,6 @@ export const NO_SESSION_FOR_PROJECT = 'VOLTER_NO_SESSION_FOR_PROJECT';
 /** The `code` of the refusal for this project's session whose manifest does not load; it carries `session`. */
 export const SESSION_MANIFEST_UNREADABLE = 'VOLTER_SESSION_MANIFEST_UNREADABLE';
 
-function readProjectSession(projectRoot: string): ProjectSessionHint | null {
-  try {
-    const value: unknown = JSON.parse(
-      readFileSync(join(projectRoot, '.volter', 'session.json'), 'utf8'),
-    );
-    if (typeof value !== 'object' || value === null) return null;
-    const hint = value as Record<string, unknown>;
-    if (
-      typeof hint['port'] !== 'number' ||
-      !Number.isInteger(hint['port']) ||
-      hint['port'] <= 0 ||
-      typeof hint['pid'] !== 'number' ||
-      typeof hint['url'] !== 'string' ||
-      typeof hint['startedAt'] !== 'string'
-    ) {
-      return null;
-    }
-    return hint as unknown as ProjectSessionHint;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Read project identity and manifest failure in one `/__editor/project` probe.
- * A serving path identifies the project even when its manifest is unreadable;
- * `project: null` without that path denotes no described project. Return
- * `undefined` when the server does not answer successfully.
- */
-async function probeServedProject(
-  port: number,
-): Promise<{ path: string | null; manifestError: string | null } | undefined> {
-  try {
-    const response = await fetch(`http://127.0.0.1:${port}/__editor/project`, {
-      signal: AbortSignal.timeout(EDITOR_SESSION_DISCOVERY_TIMEOUT_MS),
-    });
-    if (!response.ok) return undefined;
-    return servedProjectAnswer(await response.json());
-  } catch {
-    return undefined;
-  }
-}
-
 /**
  * The refusal for a session that IS this project's and cannot be driven,
  * because the project's manifest does not load.
@@ -192,8 +136,8 @@ function noMatchingSessionRefusal(
 
 /**
  * Resolve `projectDir` (default `process.cwd()`) to its already-running editor
- * session. Verify the project hint, then consult the shared registry, with
- * each discovery probe bounded by `EDITOR_SESSION_DISCOVERY_TIMEOUT_MS`.
+ * session from the shared registry, with each discovery probe bounded by
+ * `EDITOR_SESSION_DISCOVERY_TIMEOUT_MS`.
  * Throw when no project manifest or matching live session is found.
  */
 export async function resolveSession(
@@ -210,30 +154,6 @@ export async function resolveSession(
     );
   }
 
-  // The editor writes this exact-project hint at boot and removes it on
-  // shutdown. Prefer it over a global all-session scan: it is both faster and
-  // immune to an unrelated slow/dead registry entry consuming the discovery
-  // deadline. The live probe remains authoritative, so a stale file cannot
-  // attach us to the wrong project or port.
-  const localHint = (deps.readProjectSession ?? readProjectSession)(projectRoot);
-  if (localHint) {
-    // `deps.verifyProjectSession` is the test-only override and keeps its
-    // boolean meaning: "this hint is this project's session, and healthy".
-    // With no override we read the probe ourselves, because the same response
-    // carries WHY a served project cannot be described.
-    if (deps.verifyProjectSession) {
-      if (await deps.verifyProjectSession(localHint, projectRoot)) {
-        return { port: localHint.port, projectRoot };
-      }
-    } else {
-      const served = await probeServedProject(localHint.port);
-      if (served?.path != null && canonicalPath(served.path) === canonicalPath(projectRoot)) {
-        if (served.manifestError !== null) throw manifestRefusal(projectRoot, served.manifestError, localHint.port);
-        return { port: localHint.port, projectRoot };
-      }
-    }
-  }
-
   let sessions: EditorSessionInfo[];
   // Retain discovery failures separately from an empty session list so the
   // refusal names an unanswered probe rather than claiming no session exists.