@volter/sdk 0.0.0-stage → 0.5.204

package/src/http-transport.browser.ts

@@ -0,0 +1,14 @@
+/** Browser fetch owns connections and has no Node header timeout. */
+import type { Dispatcher } from 'undici';
+
+export function createDispatcher(_timeoutMs: number): undefined {
+  return undefined;
+}
+
+export function dispatchFetch(
+  url: string,
+  init?: RequestInit,
+  _dispatcher?: Dispatcher,
+): Promise<Response> {
+  return fetch(url, init);
+}

package/src/http-transport.node.ts

@@ -0,0 +1,19 @@
+/** Node session clients need explicit header deadlines for long modeling calls.
+ * Some runtimes supply an undici-compatible Agent without destroy(); callers
+ * close explicitly when that lifecycle method exists. */
+import { Agent, fetch as nodeFetch, type Dispatcher } from 'undici';
+
+export function createDispatcher(timeoutMs: number): Dispatcher {
+  return new Agent({ headersTimeout: timeoutMs, bodyTimeout: timeoutMs });
+}
+
+export async function dispatchFetch(
+  url: string,
+  init?: RequestInit,
+  dispatcher?: Dispatcher,
+): Promise<Response> {
+  if (!dispatcher) return fetch(url, init);
+  return await nodeFetch(url, {
+    ...(init as object), dispatcher,
+  }) as unknown as Response;
+}

package/src/index.ts

@@ -0,0 +1,131 @@
+export type {
+  GenerationBilling,
+  GenerationJob,
+  GenerationJobStatus,
+  GenerationJobsDocument,
+} from '@volter/sdk/generations';
+export type {
+  EditorEnvelopeObservation,
+  GameDebugDoor,
+  HistoryStep,
+  OpenedDocument,
+} from './client.js';
+export { EditorClient, EditorCommandError } from './client.js';
+export type {
+  ToolAssetInspectorContributionMatch,
+  ToolAssetInspectorContributionProps,
+  ToolContributionAsset,
+  ToolContributionNode,
+  ToolContributionProps,
+  ToolGenerationResultContributionProps,
+  ToolInspectorContributionMatch,
+  ToolInspectorContributionProps,
+} from './contributions.js';
+export type {
+  DocumentClickStep,
+  DocumentKeyStep,
+  DocumentPasteStep,
+  DocumentProbeResult,
+  DocumentProbeScope,
+  DocumentProbeStep,
+  DocumentQueryStep,
+  DocumentSelectStep,
+  DocumentTypeStep,
+  ProbedElement,
+} from './document-probe.js';
+export { EDITOR_VIEW_DIAGNOSTICS, editorViewFromUrl, editorViewUrl } from './editor-view.js';
+export type { ExtensionContributionState } from './extension.js';
+export type {
+  ActiveDocumentCapture,
+  AssetCompareCapture,
+  AssetCompareOptions,
+  AssetCompareView,
+  AssetKind,
+  AssetPreviewBackground,
+  AssetPreviewCameraChoice,
+  AssetPreviewCapture,
+  AssetPreviewOptions,
+  AssetPreviewOrientation,
+  AssetPreviewPose,
+  AssetPreviewShotSetDefinition,
+  AssetPreviewShotWarning,
+  AssetPreviewSource,
+  AssetPreviewStage,
+  AssetPreviewView,
+  CaptureDimensions,
+  DocumentCameraPose,
+  DocumentLookOutcome,
+  StageFrameCostReading,
+  DocumentTableEntryProjection,
+  DocumentTableProjection,
+  EditorCameraState,
+  EditorChromeCapture,
+  EditorChromeCaptureOptions,
+  EditorEntitySummary,
+  EditorState,
+  EditorView,
+  EditorViewBuiltInUtilityId,
+  EditorViewDocument,
+  EditorViewUtility,
+  EditorWorkspaceName,
+  GameCapture,
+  GameplayRecordingCapture,
+  GameplayRecordingOptions,
+  GameplayRecordingStarted,
+  GameplayRecordingTimeline,
+  GameplayReplayCapture,
+  HelperVisibility,
+  InspectedAction,
+  InspectedField,
+  InspectedFieldWrite,
+  InspectedHierarchy,
+  InspectedHierarchyRow,
+  InspectedInspection,
+  InspectedNothing,
+  InspectedSection,
+  InspectedSectionBody,
+  InspectedSubject,
+  InspectedWriteDestination,
+  InspectionPresentationKind,
+  InspectionSurface,
+  LabeledShotSetCapture,
+  ModelPlayLogEntry,
+  ModelPlayLogReading,
+  PlayRecordingStatus,
+  PlayStarted,
+  PresentedEditorView,
+  ProjectInfo,
+  ProjectTemplate,
+  ProjectToolCatalog,
+  ProjectToolCatalogEntry,
+  ProjectToolContribution,
+  ProjectToolOutcome,
+  RecentProject,
+  ShadingMode,
+  ShotSetPoseMorph,
+  ShotSetPoseRotation,
+  ShotSetPoseStep,
+  ShotSetPoseTranslation,
+  ShotSetShot,
+  StoryCaptureOptions,
+  StoryVariantCapture,
+  StoryVariantImage,
+  StructureOp,
+  StructureOpOptions,
+  StructureOpResult,
+  TransformMode,
+  TransformSpace,
+  Vec3Value,
+  ViewPreset,
+  ViewportCapture,
+  ViewportTab,
+} from './types.js';
+export {
+  EDITOR_VIEW_BUILT_IN_UTILITY_IDS,
+  EDITOR_VIEW_DOCUMENT_KINDS,
+  EDITOR_VIEW_KEYS,
+  EDITOR_VIEW_TOOL_UTILITY_PREFIX,
+  EDITOR_VIEW_WORKSPACE_DOCUMENT_IDS,
+  isEditorViewDocumentKind,
+  isEditorViewUtility,
+} from './types.js';

package/src/kit/CapabilityCoverageSection.tsx

@@ -0,0 +1,185 @@
+/**
+ * The human-facing projection of the ingest coverage report.
+ *
+ * The report is derived in `coverage/capability-coverage.ts`; this component never
+ * re-measures or reinterprets a seam. It only gives the same rows already
+ * exposed by the editor's `status` command and the console an Inspector-shaped reading: the
+ * measured fact first, then the consequence and the concrete fix for gaps.
+ */
+
+import {
+  faChartSimple,
+  faCircleCheck,
+  faCircleExclamation,
+  faCircleInfo,
+  faCircleMinus,
+} from '@fortawesome/free-solid-svg-icons';
+import type { LiveCoverageReport, LiveCoverageRow } from '@volter/sdk/host';
+import { EditorIcon, SectionHeader, themeVars } from '@volter/sdk/widgets';
+import type { ReactNode } from 'react';
+import type { InspectionSection } from '@volter/sdk/kit/inspection-model';
+
+/**
+ * Human labels for the seams whose names are not self-describing — the contract
+ * declarations an ingested game makes.
+ *
+ * The `editor.*` and `system.*` families are deliberately NOT listed: those are
+ * generated from the `AuthoringAdapter` / `SystemAdapters` contracts, and a
+ * hand-written label map over a generated family is the same defect the
+ * generator exists to remove — the map would silently miss whichever seam
+ * nobody remembered, in the one surface a human reads. They are humanized from
+ * the seam name instead, which cannot go stale.
+ */
+const CONTRACT_SEAM_LABEL: Partial<Record<string, string>> = {
+  loop: 'Loop control',
+  'contract.root': 'DOM root',
+  'contract.lifecycle.start': 'Cold start',
+  'contract.lifecycle.pause': 'Pause / resume',
+  persistence: 'Source persistence',
+  systems: 'Commands and state',
+};
+
+/** `editor.assetDrop` → "Asset drop"; `system.renderDebug` → "Render debug
+ *  adapter". Presentation only — the seam name itself stays the id. */
+function seamLabel(seam: string): string {
+  const explicit = CONTRACT_SEAM_LABEL[seam];
+  if (explicit) return explicit;
+  const [family, member] = seam.split('.');
+  const words = (member ?? seam).replace(/([a-z])([A-Z])/g, '$1 $2').toLowerCase();
+  const sentence = words.charAt(0).toUpperCase() + words.slice(1);
+  return family === 'system' ? `${sentence} adapter` : sentence;
+}
+
+const STATUS_ICON = {
+  ok: faCircleCheck,
+  gap: faCircleExclamation,
+  na: faCircleMinus,
+  info: faCircleInfo,
+} as const;
+
+const STATUS_COLOR = {
+  ok: themeVars.semantic.success,
+  gap: themeVars.semantic.warning,
+  na: themeVars.content.dim,
+  info: themeVars.content.dim,
+} as const;
+
+function CoverageRow({ row }: { readonly row: LiveCoverageRow }) {
+  return (
+    <div
+      data-testid={`ingest-coverage-row-${row.seam}`}
+      data-status={row.status}
+      style={{
+        display: 'grid',
+        gridTemplateColumns: '16px minmax(0, 1fr)',
+        gap: 7,
+        padding: '8px 10px',
+        borderTop: '1px solid var(--volter-structural-divider)',
+      }}
+    >
+      <span style={{ color: STATUS_COLOR[row.status], paddingTop: 1 }}>
+        <EditorIcon icon={STATUS_ICON[row.status]} />
+      </span>
+      <div style={{ minWidth: 0 }}>
+        <div style={{ color: themeVars.content.primary, fontWeight: 600 }}>
+          {seamLabel(row.seam)}
+        </div>
+        <div
+          style={{
+            marginTop: 2,
+            color: themeVars.content.muted,
+            lineHeight: 1.4,
+            overflowWrap: 'anywhere',
+          }}
+        >
+          {row.detail}
+        </div>
+        {row.missing && (
+          <div style={{ marginTop: 6, color: themeVars.content.muted, lineHeight: 1.4 }}>
+            <strong style={{ color: themeVars.semantic.warning }}>Missing:</strong> {row.missing}
+          </div>
+        )}
+        {row.fix && (
+          <div style={{ marginTop: 4, color: themeVars.content.dim, lineHeight: 1.4 }}>
+            <strong>Fix:</strong> {row.fix}
+          </div>
+        )}
+      </div>
+    </div>
+  );
+}
+
+export function CapabilityCoverageBody({ report }: { readonly report: LiveCoverageReport }) {
+  const { summary } = report;
+  return (
+    <div data-testid="ingest-coverage-report" style={{ fontSize: 'var(--volter-font-base)' }}>
+      <div
+        style={{
+          display: 'flex',
+          flexWrap: 'wrap',
+          gap: 8,
+          padding: '7px 10px 9px',
+          color: themeVars.content.muted,
+        }}
+      >
+        <span
+          style={{
+            color: summary.gaps > 0 ? themeVars.semantic.warning : themeVars.semantic.success,
+          }}
+        >
+          {summary.gaps} {summary.gaps === 1 ? 'gap' : 'gaps'}
+        </span>
+        <span>{summary.ok} integrated</span>
+        <span>{summary.na} not applicable</span>
+        <span>{summary.info} informational</span>
+      </div>
+      {report.rows.map((row) => (
+        <CoverageRow key={row.seam} row={row} />
+      ))}
+    </div>
+  );
+}
+
+/** Add the report to an ordinary composed inspection subject. The stable id
+ * means the compact Inspector keeps the same tab open while measurements
+ * refresh; sorting keeps the projection content-agnostic. */
+export function ingestCoverageSection(report: LiveCoverageReport): InspectionSection {
+  return {
+    id: 'ingest-coverage',
+    title: 'Ingest coverage',
+    icon: faChartSimple,
+    order: 9_000,
+    description: `${report.summary.gaps} gap${report.summary.gaps === 1 ? '' : 's'}`,
+    defaultOpen: true,
+    testId: 'ingest-coverage-section',
+    body: {
+      kind: 'custom',
+      render: (): ReactNode => <CapabilityCoverageBody report={report} />,
+      // `editor.inspect()` cannot render React. Publish exactly what this body
+      // displays so the agent and the human read the same report through the
+      // Inspector rather than forcing the agent back to a parallel status
+      // shape.
+      data: { summary: report.summary, rows: report.rows },
+    },
+  };
+}
+
+/** The nothing-to-author Inspector has no composed subject/section list, so it uses
+ * the same section as a directly headed block instead of inventing a second
+ * presentation for the report. */
+export function CapabilityCoverageBlock({ report }: { readonly report: LiveCoverageReport }) {
+  const section = ingestCoverageSection(report);
+  return (
+    <div data-testid={section.testId}>
+      <SectionHeader
+        label={section.title}
+        icon={section.icon}
+        description={section.description}
+        collapsible
+        defaultOpen
+      >
+        <CapabilityCoverageBody report={report} />
+      </SectionHeader>
+    </div>
+  );
+}

package/src/kit/account-client.ts

@@ -0,0 +1,333 @@
+import type {
+  AccountCatalog,
+  AccountSpendPolicy,
+  AccountUsageEntry,
+  EditorAccountSnapshot,
+  GenerationAccountProjection,
+  GenerationExecutionRoute,
+  ProviderCredentialId,
+  ProviderCredentialTestResult,
+} from '@volter/sdk/account';
+import {
+  AccountCatalogSchema,
+  AccountUsageEntrySchema,
+  EditorAccountSnapshotSchema,
+  generationAccountProjection,
+  ProviderCredentialTestResultSchema,
+} from '@volter/sdk/account';
+import { assertEditorServerAnswered } from '@volter/sdk/kit/editor-server-response';
+import { COLLABORATION_REMOTE_SHARE } from '@volter/sdk/kit/editor-session-attribution';
+
+const EMPTY: EditorAccountSnapshot = {
+  authenticated: false,
+  backend: 'mock',
+  accountEnvironment: 'test-mock',
+  routes: { mock: true, managed: false, byok: false, byokProviders: [] },
+  preferredRoute: 'auto',
+  providerCredentials: [],
+  codingInference: { enabled: false, provider: 'openrouter', model: 'z-ai/glm-5.2' },
+};
+let snapshot: EditorAccountSnapshot = EMPTY;
+let version = 0;
+let error: string | null = null;
+const listeners = new Set<() => void>();
+
+function publish(next: EditorAccountSnapshot, nextError: string | null = null) {
+  // Polling identical state must not invalidate every contribution. Parsed
+  // snapshots have the schema's stable field order; errors are state too.
+  if (error === nextError && JSON.stringify(snapshot) === JSON.stringify(next)) return;
+  snapshot = next;
+  error = nextError;
+  version++;
+  for (const listener of listeners) listener();
+}
+
+// Every route below reads the account service's OWN `{ error }` body on a
+// non-OK status (that string is the user-facing message — "Insufficient
+// credits", not "402"), so each one asserts only that the EDITOR SERVER
+// answered, before parsing. See `editor-server-response.ts`.
+async function responseSnapshot(response: Response, what: string): Promise<EditorAccountSnapshot> {
+  assertEditorServerAnswered(response, what);
+  const body = (await response.json()) as EditorAccountSnapshot | { error?: unknown };
+  if (!response.ok) {
+    throw new Error(
+      typeof (body as { error?: unknown }).error === 'string'
+        ? String((body as { error?: unknown }).error)
+        : `Account request failed (${response.status}).`,
+    );
+  }
+  return EditorAccountSnapshotSchema.parse(body);
+}
+
+async function mutate(path: string, method: 'POST' | 'PUT' | 'DELETE', body?: unknown) {
+  const response = await fetch(path, {
+    method,
+    ...(body === undefined
+      ? {}
+      : { headers: { 'Content-Type': 'application/json' }, body: JSON.stringify(body) }),
+  });
+  const next = await responseSnapshot(response, `${method} ${path} failed`);
+  publish(next);
+  return next;
+}
+
+export function accountSnapshot(): EditorAccountSnapshot {
+  return snapshot;
+}
+/** The deliberately narrow, non-PII account view exposed to project code. */
+export function contributionAccount(): GenerationAccountProjection {
+  return generationAccountProjection(snapshot);
+}
+export function accountVersion(): number {
+  return version;
+}
+export function accountError(): string | null {
+  return error;
+}
+export function subscribeAccount(listener: () => void): () => void {
+  listeners.add(listener);
+  return () => listeners.delete(listener);
+}
+export async function refreshAccount(): Promise<EditorAccountSnapshot> {
+  try {
+    const next = await responseSnapshot(await fetch('/__editor/account'), 'Account read failed');
+    publish(next);
+    return next;
+  } catch (cause) {
+    publish(snapshot, cause instanceof Error ? cause.message : String(cause));
+    throw cause;
+  }
+}
+export const signInMockAccount = (email: string) =>
+  mutate('/__editor/account/mock-session', 'POST', { email });
+export const signInTwinAccount = (email: string) =>
+  mutate('/__editor/account/twin-session', 'POST', { email });
+export const signOutAccount = () => mutate('/__editor/account/session', 'DELETE');
+export const updateAccountSpendPolicy = (policy: AccountSpendPolicy) =>
+  mutate('/__editor/account/spend-policy', 'PUT', policy);
+export const markAccountAlertsRead = () => mutate('/__editor/account/alerts/read', 'POST');
+export const updatePreferredGenerationRoute = (route: GenerationExecutionRoute) =>
+  mutate('/__editor/account/execution-route', 'PUT', { route });
+export const updateCodingInference = (input: EditorAccountSnapshot['codingInference']) =>
+  mutate('/__editor/account/coding-inference', 'PUT', input);
+export async function quoteCodingInference(input: {
+  model: string;
+  promptTokens: number;
+  outputTokens: number;
+}): Promise<{
+  model: string;
+  promptTokens: number;
+  outputTokens: number;
+  providerAmountUsd: number;
+  estimatedCredits: number;
+}> {
+  const response = await fetch('/__editor/account/coding-inference/quote', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(input),
+  });
+  assertEditorServerAnswered(response, 'Coding quote failed');
+  const body = (await response.json()) as {
+    model?: unknown;
+    promptTokens?: unknown;
+    outputTokens?: unknown;
+    providerAmountUsd?: unknown;
+    estimatedCredits?: unknown;
+    error?: unknown;
+  };
+  if (
+    !response.ok ||
+    typeof body.model !== 'string' ||
+    typeof body.promptTokens !== 'number' ||
+    typeof body.outputTokens !== 'number' ||
+    typeof body.providerAmountUsd !== 'number' ||
+    typeof body.estimatedCredits !== 'number'
+  ) {
+    throw new Error(typeof body.error === 'string' ? body.error : 'Coding quote failed.');
+  }
+  return body as {
+    model: string;
+    promptTokens: number;
+    outputTokens: number;
+    providerAmountUsd: number;
+    estimatedCredits: number;
+  };
+}
+export const saveProviderCredential = (provider: ProviderCredentialId, key: string) =>
+  mutate(`/__editor/account/provider-credentials/${encodeURIComponent(provider)}`, 'PUT', { key });
+export const removeProviderCredential = (provider: ProviderCredentialId) =>
+  mutate(`/__editor/account/provider-credentials/${encodeURIComponent(provider)}`, 'DELETE');
+export async function testProviderCredential(
+  provider: ProviderCredentialId,
+): Promise<ProviderCredentialTestResult> {
+  const response = await fetch(
+    `/__editor/account/provider-credentials/${encodeURIComponent(provider)}/test`,
+    { method: 'POST' },
+  );
+  assertEditorServerAnswered(response, 'Credential test failed');
+  const body = (await response.json()) as ProviderCredentialTestResult & { error?: unknown };
+  if (!response.ok) {
+    throw new Error(
+      typeof body.error === 'string' ? body.error : `Credential test failed (${response.status}).`,
+    );
+  }
+  return ProviderCredentialTestResultSchema.parse(body);
+}
+export const updateAccountPlan = (action: 'cancel' | 'resume') =>
+  mutate('/__editor/account/plan', 'PUT', { action });
+async function checkoutAction(
+  path: string,
+  body: unknown,
+): Promise<{ checkoutUrl?: string; mock: boolean }> {
+  const response = await fetch(path, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Idempotency-Key': crypto.randomUUID(),
+    },
+    body: JSON.stringify(body),
+  });
+  assertEditorServerAnswered(response, 'Checkout failed');
+  const result = (await response.json()) as {
+    account?: unknown;
+    checkoutUrl?: unknown;
+    mock?: unknown;
+    error?: unknown;
+  };
+  if (!response.ok || !result.account) {
+    throw new Error(typeof result.error === 'string' ? result.error : 'Checkout failed.');
+  }
+  publish(EditorAccountSnapshotSchema.parse(result.account));
+  return {
+    ...(typeof result.checkoutUrl === 'string' ? { checkoutUrl: result.checkoutUrl } : {}),
+    mock: result.mock === true,
+  };
+}
+export const checkoutAccountPlan = (plan: string) =>
+  checkoutAction('/__editor/account/checkout', { plan });
+export const purchaseAccountCredits = (packId: string) =>
+  checkoutAction('/__editor/account/credits', { packId });
+export async function fetchAccountUsage(): Promise<AccountUsageEntry[]> {
+  const response = await fetch('/__editor/account/usage');
+  assertEditorServerAnswered(response, 'Usage failed');
+  const body = (await response.json()) as { entries?: AccountUsageEntry[]; error?: unknown };
+  if (!response.ok) throw new Error(typeof body.error === 'string' ? body.error : 'Usage failed.');
+  return AccountUsageEntrySchema.array().parse(body.entries ?? []);
+}
+export async function fetchAccountCatalog(): Promise<AccountCatalog> {
+  const response = await fetch('/__editor/account/catalog');
+  assertEditorServerAnswered(response, 'Catalog failed');
+  const body = (await response.json()) as AccountCatalog & { error?: unknown };
+  if (!response.ok)
+    throw new Error(typeof body.error === 'string' ? body.error : 'Catalog failed.');
+  return AccountCatalogSchema.parse(body);
+}
+export async function openAccountBillingPortal(): Promise<{ url: string; mock: boolean }> {
+  const response = await fetch('/__editor/account/billing-portal', { method: 'POST' });
+  assertEditorServerAnswered(response, 'Billing portal failed');
+  const body = (await response.json()) as { url?: unknown; mock?: unknown; error?: unknown };
+  if (!response.ok || typeof body.url !== 'string') {
+    throw new Error(typeof body.error === 'string' ? body.error : 'Billing portal failed.');
+  }
+  return { url: body.url, mock: body.mock === true };
+}
+export interface DeviceAuthorization {
+  deviceCode: string;
+  userCode: string;
+  verificationUri: string;
+  expiresAt: string;
+  intervalSeconds: number;
+}
+export interface BrowserAuthorization {
+  authorizationId: string;
+  authorizationUrl: string;
+  expiresAt: string;
+}
+export async function fetchAccountAuthorizationMethods(): Promise<{
+  browser: true;
+  device: boolean;
+}> {
+  const response = await fetch('/__editor/account/authorization-methods');
+  assertEditorServerAnswered(response, 'Sign-in methods are unavailable');
+  const body = (await response.json()) as {
+    browser?: unknown;
+    device?: unknown;
+    error?: unknown;
+  };
+  if (!response.ok || body.browser !== true || typeof body.device !== 'boolean') {
+    throw new Error(
+      typeof body.error === 'string' ? body.error : 'Sign-in methods are unavailable.',
+    );
+  }
+  return { browser: true, device: body.device };
+}
+export async function beginAccountBrowserAuthorization(): Promise<BrowserAuthorization> {
+  const response = await fetch('/__editor/account/browser-authorization', { method: 'POST' });
+  assertEditorServerAnswered(response, 'Sign-in failed');
+  const body = (await response.json()) as BrowserAuthorization & { error?: unknown };
+  if (!response.ok) {
+    throw new Error(typeof body.error === 'string' ? body.error : 'Sign-in failed.');
+  }
+  return body;
+}
+export async function pollAccountBrowserAuthorization(authorizationId: string): Promise<boolean> {
+  const response = await fetch(
+    `/__editor/account/browser-authorization/${encodeURIComponent(authorizationId)}`,
+  );
+  assertEditorServerAnswered(response, 'Sign-in failed');
+  const body = (await response.json()) as
+    | { pending: true; error?: unknown }
+    | { pending: false; account: EditorAccountSnapshot; error?: unknown };
+  if (response.status === 202) return false;
+  if (!response.ok || body.pending !== false) {
+    throw new Error(typeof body.error === 'string' ? body.error : 'Sign-in failed.');
+  }
+  publish(EditorAccountSnapshotSchema.parse(body.account));
+  return true;
+}
+export async function beginAccountDeviceAuthorization(): Promise<DeviceAuthorization> {
+  const response = await fetch('/__editor/account/device-authorization', { method: 'POST' });
+  assertEditorServerAnswered(response, 'Sign-in failed');
+  const body = (await response.json()) as DeviceAuthorization & { error?: unknown };
+  if (!response.ok)
+    throw new Error(typeof body.error === 'string' ? body.error : 'Sign-in failed.');
+  return body;
+}
+export async function pollAccountDeviceAuthorization(deviceCode: string): Promise<boolean> {
+  const response = await fetch(
+    `/__editor/account/device-authorization/${encodeURIComponent(deviceCode)}`,
+  );
+  assertEditorServerAnswered(response, 'Sign-in failed');
+  const body = (await response.json()) as
+    | { pending: true; error?: unknown }
+    | { pending: false; account: EditorAccountSnapshot; error?: unknown };
+  if (response.status === 202) return false;
+  if (!response.ok || body.pending !== false) {
+    throw new Error(typeof body.error === 'string' ? body.error : 'Sign-in failed.');
+  }
+  publish(EditorAccountSnapshotSchema.parse(body.account));
+  return true;
+}
+export function startAccountActivity(): () => void {
+  if (COLLABORATION_REMOTE_SHARE) return () => {};
+  const checkoutId = new URLSearchParams(window.location.search).get('checkout_id');
+  if (checkoutId) {
+    void mutate('/__editor/account/checkout/confirm', 'POST', { checkoutId })
+      .then(() => {
+        const url = new URL(window.location.href);
+        url.searchParams.delete('checkout');
+        url.searchParams.delete('checkout_id');
+        window.history.replaceState(null, '', `${url.pathname}${url.search}${url.hash}`);
+      })
+      // Into the module's own error channel (`accountError()`, rendered by the
+      // account UI) rather than a bare swallow: a confirm that reached nothing
+      // used to clear the URL params and look done.
+      .catch((cause: unknown) =>
+        publish(snapshot, cause instanceof Error ? cause.message : String(cause)),
+      );
+  } else {
+    void refreshAccount().catch(() => undefined);
+  }
+  const timer = window.setInterval(() => void refreshAccount().catch(() => undefined), 30_000);
+  return () => window.clearInterval(timer);
+}