@zackbart/connecta 0.9.1 → 0.10.1

package/src/executors/quickjs-protocol.ts

@@ -57,6 +57,25 @@ export interface ExecutionPayload {
   timedOut?: boolean;
 }
 
+/**
+ * How a host call should be named in an error a program will read. The lazy
+ * connector namespaces all dispatch through one internal function, so the raw
+ * provider/function pair would report every shortcut call as
+ * `connecta.__callNamespace` — an internal name that appears nowhere in the
+ * documented surface. Report the address the program actually called.
+ */
+export function hostCallLabel(payload: {
+  namespace: string;
+  functionName: string;
+  args: unknown[];
+}): string {
+  if (payload.functionName === "__callNamespace") {
+    const [connectorId, toolAlias] = payload.args;
+    return `${String(connectorId)}.${String(toolAlias)}`;
+  }
+  return `${payload.namespace}.${payload.functionName}`;
+}
+
 export function serializedBytes(text: string): number {
   return new TextEncoder().encode(text).length;
 }

package/src/executors/quickjs-runtime.ts

@@ -15,6 +15,7 @@ import {
 } from "quickjs-emscripten";
 import type { ExecuteResult, ExecutorProvider } from "../types.js";
 import {
+  hostCallLabel,
   MAX_QUICKJS_LOG_TRANSPORT_BYTES,
   serializedBytes,
 } from "./quickjs-protocol.js";
@@ -245,18 +246,21 @@ function installBridge(
           : undefined;
       if (!f) throw new Error(`Unknown function ${ns}.${fn}`);
       const args = JSON.parse(argsJson) as unknown[];
+      // Name the address the program called, never the internal dispatcher the
+      // lazy connector namespaces share.
+      const label = hostCallLabel({ namespace: ns, functionName: fn, args });
       const value = await f(...args);
       let json: string;
       try {
         json = JSON.stringify({ ok: true, value });
       } catch (err) {
         throw new Error(
-          `Host result from ${ns}.${fn} could not be serialized: ${msg(err)}`,
+          `Host result from ${label} could not be serialized: ${msg(err)}`,
         );
       }
       if (exceedsUtf8ByteLimit(json, MAX_HOST_RESULT_BYTES)) {
         throw new Error(
-          `Host result from ${ns}.${fn} exceeds the ${MAX_HOST_RESULT_BYTES}-byte serialized bridge limit.`,
+          `Host result from ${label} exceeds the ${MAX_HOST_RESULT_BYTES}-byte serialized bridge limit.`,
         );
       }
       return json;

package/src/executors/quickjs.ts

@@ -18,6 +18,7 @@ import type {
   ExecutorProvider,
 } from "../types.js";
 import {
+  hostCallLabel,
   MAX_QUICKJS_IPC_BYTES,
   MAX_QUICKJS_HOST_RPC_BYTES,
   type ChildToParentMessage,
@@ -593,6 +594,9 @@ class QuickJsChildPool implements AdmittingExecutor {
         serializedBytes(message.payloadJson) >
         MAX_QUICKJS_HOST_RPC_BYTES
       ) {
+        // Refused before parsing, so there is no address to name here: parsing
+        // an over-limit payload to improve its error message would spend the
+        // work the limit exists to refuse.
         throw new RangeError("Host call arguments exceeded the IPC limit.");
       }
       const payload = JSON.parse(message.payloadJson) as HostCallPayload;
@@ -610,14 +614,17 @@ class QuickJsChildPool implements AdmittingExecutor {
       try {
         payloadJson = stringifyBounded(
           { ok: true, value } satisfies HostResultPayload,
-          `Host result from ${payload.namespace}.${payload.functionName}`,
+          `Host result from ${hostCallLabel(payload)}`,
           MAX_QUICKJS_HOST_RPC_BYTES,
         );
       } catch (err) {
+        // The guest reads this text, so it names the address the program called
+        // rather than the internal dispatcher every shortcut namespace shares.
+        const label = hostCallLabel(payload);
         const detail =
           err instanceof RangeError
-            ? `Host result from ${payload.namespace}.${payload.functionName} exceeds the ${MAX_QUICKJS_HOST_RPC_BYTES}-byte serialized bridge limit.`
-            : `Host result from ${payload.namespace}.${payload.functionName} could not be serialized: ${msg(err)}`;
+            ? `Host result from ${label} exceeds the ${MAX_QUICKJS_HOST_RPC_BYTES}-byte serialized bridge limit.`
+            : `Host result from ${label} could not be serialized: ${msg(err)}`;
         payloadJson = errorPayload(detail);
       }
     } catch (err) {

package/src/index.ts

@@ -3,6 +3,7 @@ import {
   credentialTestRule,
   describeCredentialTestMismatch,
 } from "./credentials.js";
+import { AccessTokenManager } from "./access-tokens.js";
 import { Registry } from "./registry.js";
 import { createFetchHandler } from "./server.js";
 import { droppedBrandingUrls, droppedUiAuthUrls } from "./ui.js";
@@ -17,6 +18,7 @@ import type { ActivityReadGate, ActivityStore } from "./activity.js";
 import type {
   Connector,
   ConnectaBranding,
+  ConnectaSurface,
   Executor,
   InboundAuth,
   KVStorage,
@@ -48,6 +50,12 @@ export interface ConnectaCredentialsConfig {
   encryptionKey?: string;
 }
 
+/** Operator-issued credentials for clients connecting to this deployment. */
+export interface ConnectaAccessTokensConfig {
+  /** Maximum simultaneously active access tokens. Defaults to 100. */
+  maxActive?: number;
+}
+
 /** Tool-catalog caching, persistence, stale fallback, and probe deadlines. */
 export interface ConnectaDiscoveryConfig {
   /**
@@ -147,6 +155,11 @@ export interface ConnectaConfig {
   activity?: ConnectaActivityConfig;
   /** Operator credential vault settings. */
   credentials?: ConnectaCredentialsConfig;
+  /**
+   * Named, revocable Bearer tokens for MCP clients. Creation and mutation
+   * require an eligible Clerk operator; token secrets are returned once.
+   */
+  accessTokens?: ConnectaAccessTokensConfig;
   /** Tool-catalog caching, persistence, stale fallback, and probe deadlines. */
   discovery?: ConnectaDiscoveryConfig;
   /** Deployment-wide call deadlines and result paging threshold. */
@@ -169,12 +182,22 @@ export interface ConnectaConfig {
   /** Deployment metadata exposed by /health (for example a Worker version). */
   deploymentInfo?: Record<string, unknown>;
   /**
-   * Sandbox for the optional execute_code meta-tool (code mode). Omit → the
-   * tool is not registered and connecta serves the nine base tools. Workers:
-   * `new DynamicWorkerExecutor({ loader: env.LOADER })` from
-   * `@cloudflare/codemode`. Node: `quickJsExecutor()` from "@zackbart/connecta/quickjs".
+   * Sandbox for `execute_code`, and the switch that decides the surface: with
+   * an executor a model sees the seven code-first tools, without one the nine
+   * classic ones. Workers: `new DynamicWorkerExecutor({ loader: env.LOADER })`
+   * from `@cloudflare/codemode`. Node: `quickJsExecutor()` from
+   * "@zackbart/connecta/quickjs".
    */
   executor?: Executor;
+  /**
+   * Override the surface the `executor` implies. The only reason to set it is
+   * `"classic"` alongside an executor — ten tools, the shape the eval gate's
+   * *incremental* arm measures ("does adding `execute_code` to classic help on
+   * its own?"). The gate's control arm is executor-free classic, which needs no
+   * override. `"code-first"` is the default wherever an executor exists and
+   * throws without one.
+   */
+  surface?: ConnectaSurface;
 }
 
 export interface Connecta {
@@ -406,8 +429,43 @@ function warnInsecureConfig(
   }
 }
 
+/**
+ * The advertised surface: the executor is the switch. Configure one and the
+ * deployment serves the seven-tool code-first surface; omit it and there is no
+ * program to fold discovery and batching into, so it serves classic.
+ *
+ * Two mistakes are structural rather than recoverable, so neither is warned
+ * past: a surface name connecta does not implement, which would otherwise
+ * resolve to something the operator did not ask for; and `code-first` without
+ * an executor, which would advertise six tools and no program surface.
+ */
+function resolveSurface(config: ConnectaConfig): ConnectaSurface {
+  const surface = config.surface;
+  if (surface === undefined) {
+    return config.executor ? "code-first" : "classic";
+  }
+  if (surface !== "classic" && surface !== "code-first") {
+    throw new Error(
+      `ConnectaConfig.surface must be "classic" or "code-first", not ` +
+        `${JSON.stringify(surface)}.`,
+    );
+  }
+  if (surface === "code-first" && !config.executor) {
+    throw new Error(
+      'ConnectaConfig.surface "code-first" requires an executor: it folds ' +
+        "list_connectors, describe_tools, and batch_call into connecta.search, " +
+        "connecta.describe, and connecta.batch inside execute_code, so without " +
+        "an executor there is nothing left to reach them through. Configure " +
+        "one (quickJsExecutor() from \"@zackbart/connecta/quickjs\" on Node, " +
+        "new DynamicWorkerExecutor({ loader: env.LOADER }) on Workers).",
+    );
+  }
+  return surface;
+}
+
 export function createConnecta(config: ConnectaConfig): Connecta {
   assertNoLegacyConfig(config);
+  const surface = resolveSurface(config);
   const storage = config.storage ?? memoryStorage();
   const logger = config.logger ?? defaultLogger();
   const credentialConnectors = config.connectors.filter((c) => c.credential);
@@ -422,6 +480,19 @@ export function createConnecta(config: ConnectaConfig): Connecta {
   const credentialVault = encryptionKey
     ? new CredentialVault(storage, encryptionKey)
     : undefined;
+  const configuredAuth = normalizeAuth(config.auth);
+  const accessTokens = config.accessTokens
+    ? new AccessTokenManager(storage, config.accessTokens)
+    : undefined;
+  if (
+    accessTokens &&
+    !configuredAuth.some((provider) => provider.uiAuth?.kind === "clerk")
+  ) {
+    throw new Error(
+      "accessTokens requires a Clerk auth provider: only an eligible Clerk " +
+        "operator may create, rename, or revoke deployment access tokens",
+    );
+  }
   const registry = new Registry(config.connectors, {
     storage,
     logger,
@@ -442,7 +513,9 @@ export function createConnecta(config: ConnectaConfig): Connecta {
       ? { maxBatchResultBytes: config.calls.maxBatchResultBytes }
       : {}),
   });
-  const inboundAuth = normalizeAuth(config.auth);
+  const inboundAuth = normalizeAuth(
+    accessTokens ? [accessTokens.auth, ...configuredAuth] : configuredAuth,
+  );
   warnInsecureConfig(config, inboundAuth, logger);
   const requestAdmission = admissionController(
     config.admission?.requests,
@@ -484,6 +557,7 @@ export function createConnecta(config: ConnectaConfig): Connecta {
       ? { activityDeploymentId: config.activity.deploymentId }
       : {}),
     ...(executor !== undefined ? { executor } : {}),
+    surface,
     requestAdmission,
     ...(config.calls?.defaultTimeoutMs !== undefined
       ? { defaultToolTimeoutMs: config.calls.defaultTimeoutMs }
@@ -495,6 +569,7 @@ export function createConnecta(config: ConnectaConfig): Connecta {
       ? { discoveryConcurrency: config.discovery.concurrency }
       : {}),
     ...(credentialVault !== undefined ? { credentialVault } : {}),
+    ...(accessTokens !== undefined ? { accessTokens } : {}),
     ...(config.deploymentInfo !== undefined
       ? { deploymentInfo: config.deploymentInfo }
       : {}),
@@ -533,6 +608,10 @@ export { validateToolInput } from "./validate.js";
 export type { ValidateToolInputOptions } from "./validate.js";
 export { bearerToken } from "./auth/bearer.js";
 export type { BearerTokenOptions } from "./auth/bearer.js";
+export type {
+  AccessTokenMetadata,
+  CreatedAccessToken,
+} from "./access-tokens.js";
 export { memoryStorage } from "./storage/memory.js";
 export { CONNECTA_VERSION } from "./version.js";
 // Registry is reachable through `Connecta.registry`, so its type is public;
@@ -553,6 +632,7 @@ export type {
   ConnectorCallAdmissionRule,
   ConnectorRollingWindowBudget,
   ConnectaBranding,
+  ConnectaSurface,
   ConnectorCredentialAccess,
   ConnectorCredentialConfig,
   ConnectorCredentialFieldConfig,

package/src/invocation.ts

@@ -12,7 +12,7 @@ import {
 import {
   classifyCallError,
   ConnectorCallError,
-  messageLooksRetryable,
+  framingError,
   type AuthRecoveryMode,
   type CallErrorDetails,
 } from "./errors.js";
@@ -70,10 +70,6 @@ function retrySafe(definition: ToolDef): boolean {
   );
 }
 
-function framingError(code: string, message: string): CallErrorDetails {
-  return { code, message, retryable: messageLooksRetryable(message) };
-}
-
 function callerCancelledDetails(): CallErrorDetails {
   return {
     code: "cancelled",

package/src/meta-tools.ts

@@ -49,7 +49,11 @@ import {
   normalizeTimeoutMs,
   withAbortableTimeout,
 } from "./timeout.js";
-import type { ConnectorStatus, KVStorage } from "./types.js";
+import type {
+  ConnectaSurface,
+  ConnectorStatus,
+  KVStorage,
+} from "./types.js";
 
 export {
   MAX_DESCRIBE_ADDRESSES,
@@ -473,10 +477,12 @@ export interface SkillArgs {
 }
 
 /**
- * The nine meta-tool handlers over a registry. Exported for direct testing;
- * registerMetaTools() wires them onto an McpServer. `opts.defaultToolTimeoutMs`
- * supplies a deadline for calls that don't carry one. (execute_code, the
- * optional tenth tool, is registered separately by registerExecuteTool.)
+ * Every base meta-tool handler over a registry — all nine, whichever surface is
+ * advertised, since folding a tool away only skips its registration and never
+ * its handler. Exported for direct testing; registerMetaTools() wires the ones
+ * this surface advertises onto an McpServer. `opts.defaultToolTimeoutMs`
+ * supplies a deadline for calls that don't carry one. (execute_code is
+ * registered separately by registerExecuteTool.)
  *
  * Deployment-wide result-size caps are read off the registry view rather than
  * passed in: `ConnectaConfig.calls.maxResultBytes`, its per-connector override,
@@ -498,8 +504,15 @@ export function createMetaTools(
     requestSignal?: AbortSignal;
     /** Runtime continuation for the bounded tail of probe-owned teardown. */
     defer?: DeferredWork;
+    /**
+     * The advertised surface, which the `skills` guidance must match: a
+     * code-first deployment never gets guidance naming a tool it does not
+     * advertise. Default `classic`.
+     */
+    surface?: ConnectaSurface;
   } = {},
 ) {
+  const surface: ConnectaSurface = opts.surface ?? "classic";
   // Already normalized and warned about at registry construction.
   const globalCap = registry.maxResultBytes;
   const batchCap = registry.maxBatchResultBytes;
@@ -666,14 +679,14 @@ export function createMetaTools(
               type: "text",
               text:
                 'Available skills. Fetch one with skills({ name: "<name>" }).\n\n' +
-                listSkills(connectors)
+                listSkills(connectors, surface)
                   .map((skill) => `- \`${skill.name}\` — ${skill.description}`)
                   .join("\n"),
             },
           ],
         };
       }
-      const skill = resolveSkill(args.name, connectors);
+      const skill = resolveSkill(args.name, connectors, surface);
       if (!skill.found) return errorResult(skill.message);
       return { content: [{ type: "text", text: skill.content }] };
     },
@@ -1133,6 +1146,23 @@ const AUTHORIZE_DESC =
 const SKILLS_DESC =
   'List or fetch concise guidance for choosing among Connecta meta-tools. Call skills({ name: "usage" }) once when the routing workflow is unfamiliar; do not refetch it in the same task.';
 
+/**
+ * Code-first replacements for the descriptions that route work between tools.
+ * Every one of these mentions a tool the consolidated surface removed, so on a
+ * code-first deployment the routing sentence has to point at the in-program
+ * function that took the work over — a description naming `batch_call` on a
+ * surface without one teaches a call that cannot succeed.
+ *
+ * The classic strings above are left byte-for-byte alone: classic is the
+ * compatibility surface and the eval's control arm, and rewording it would
+ * change what that control measures.
+ */
+const CODE_FIRST_SEARCH_DESC = `${SEARCH_DESC} Expand an ambiguous compact shape, or read exact JSON constraints, with connecta.describe inside execute_code.`;
+const CODE_FIRST_CALL_DESC =
+  'Use for ONE tool explicitly annotated readOnlyHint: true — the cheapest path for a single cold call. For two or more calls, dependent steps, loops, joins, or data reduction use execute_code, whose connecta.call and connecta.batch reach the same tools. Unannotated, write-capable, and destructive tools are refused and require call_destructive_tool. fields selects JSON dot-paths, resultMode "value" unwraps results, timeoutMs sets a deadline, safe maxRetries are annotation-gated, diagnostics adds timing, and large results page through get_result.';
+const CODE_FIRST_GET_RESULT_DESC =
+  "Page a truncated result stashed by call_tool or call_destructive_tool; a program's oversized return is not paged, so reduce it in code instead. Input { id, offset?, maxBytes? } → { text, offset, nextOffset?, totalBytes } sliced by byte offset. maxBytes is a whole number of bytes >= 1 (omit for the deployment default) and offset a whole number of bytes >= 0; an offset inside a multi-byte character is moved back to that character's first byte and the offset served is returned. Unknown/expired id is an error.";
+
 /**
  * Sentences appended to a meta-tool description only when this connection
  * actually has connector guides. Tool descriptions are always-loaded context,
@@ -1191,7 +1221,17 @@ const CALL_INPUT_SCHEMA = {
   diagnostics: z.boolean().optional(),
 };
 
-/** Register the nine meta-tools onto an McpServer instance. */
+/**
+ * Register the base meta-tools onto an McpServer instance: nine on the classic
+ * surface, six on the code-first one, where `list_connectors`,
+ * `describe_tools`, and `batch_call` have folded into the program surface
+ * (`registerExecuteTool` adds the seventh, `execute_code`).
+ *
+ * Only the registrations differ. Every handler still exists on the object
+ * `createMetaTools` returns, and a folded tool's behavior is reached through
+ * `connecta.search` / `connecta.describe` / `connecta.batch` inside a program —
+ * the same code paths, one layer down.
+ */
 export function registerMetaTools(
   server: McpServer,
   registry: RegistryView,
@@ -1203,9 +1243,14 @@ export function registerMetaTools(
     activity?: ActivityRequestContext;
     requestSignal?: AbortSignal;
     defer?: DeferredWork;
+    /** The advertised surface. Default `classic`. */
+    surface?: ConnectaSurface;
   },
 ): void {
+  const surface: ConnectaSurface = ctx.surface ?? "classic";
+  const codeFirst = surface === "code-first";
   const mt = createMetaTools(registry, ctx.baseUrl, {
+    surface,
     ...(ctx.defaultToolTimeoutMs !== undefined
       ? { defaultToolTimeoutMs: ctx.defaultToolTimeoutMs }
       : {}),
@@ -1232,20 +1277,30 @@ export function registerMetaTools(
     async (args) => mt.skills(args as SkillArgs),
   );
 
-  server.registerTool(
-    "list_connectors",
-    {
-      description: LIST_DESC,
-      inputSchema: z.object({ probe: z.boolean().optional() }),
-      annotations: READ_ONLY_REMOTE,
-    },
-    async (args) => mt.listConnectors(args as ListArgs),
-  );
+  // Folded on the code-first surface: a program browses the same inventory with
+  // connecta.search({}) (every catalog) or connecta.search({ connector }) (one).
+  // Live connector probing is an operator concern, not a model one — it stays on
+  // the operator pages and /health, which is where the ethos puts observability.
+  if (!codeFirst) {
+    server.registerTool(
+      "list_connectors",
+      {
+        description: LIST_DESC,
+        inputSchema: z.object({ probe: z.boolean().optional() }),
+        annotations: READ_ONLY_REMOTE,
+      },
+      async (args) => mt.listConnectors(args as ListArgs),
+    );
+  }
 
   server.registerTool(
     "search_tools",
     {
-      description: describedFor(registry, SEARCH_DESC, "search"),
+      description: describedFor(
+        registry,
+        codeFirst ? CODE_FIRST_SEARCH_DESC : SEARCH_DESC,
+        "search",
+      ),
       inputSchema: z.object({
         query: z.string().optional(),
         connector: z.string().optional(),
@@ -1259,24 +1314,28 @@ export function registerMetaTools(
     async (args) => mt.searchTools(args as SearchArgs),
   );
 
-  server.registerTool(
-    "describe_tools",
-    {
-      description: describedFor(registry, DESCRIBE_DESC, "describe"),
-      inputSchema: z.object({
-        addresses: z.array(z.string()).max(MAX_DESCRIBE_ADDRESSES),
-        format: z.enum(["compact", "json"]).optional(),
-        fullDescriptions: z.boolean().optional(),
-      }),
-      annotations: READ_ONLY_REMOTE,
-    },
-    async (args) => mt.describeTools(args as DescribeArgs),
-  );
+  // Folded on the code-first surface: connecta.describe takes the same
+  // addresses, format, and per-address error reporting inside a program.
+  if (!codeFirst) {
+    server.registerTool(
+      "describe_tools",
+      {
+        description: describedFor(registry, DESCRIBE_DESC, "describe"),
+        inputSchema: z.object({
+          addresses: z.array(z.string()).max(MAX_DESCRIBE_ADDRESSES),
+          format: z.enum(["compact", "json"]).optional(),
+          fullDescriptions: z.boolean().optional(),
+        }),
+        annotations: READ_ONLY_REMOTE,
+      },
+      async (args) => mt.describeTools(args as DescribeArgs),
+    );
+  }
 
   server.registerTool(
     "call_tool",
     {
-      description: CALL_DESC,
+      description: codeFirst ? CODE_FIRST_CALL_DESC : CALL_DESC,
       inputSchema: z.object(CALL_INPUT_SCHEMA),
       // call_tool admits only tools that are themselves explicitly read-only;
       // anything else is refused and routed to call_destructive_tool.
@@ -1321,7 +1380,7 @@ export function registerMetaTools(
   server.registerTool(
     "get_result",
     {
-      description: GET_RESULT_DESC,
+      description: codeFirst ? CODE_FIRST_GET_RESULT_DESC : GET_RESULT_DESC,
       inputSchema: z.object({
         id: z.string(),
         // Both bounds are the shared rules (isValidResultOffset,
@@ -1336,24 +1395,28 @@ export function registerMetaTools(
     async (args) => mt.getResult(args as GetResultArgs),
   );
 
-  server.registerTool(
-    "batch_call",
-    {
-      description: BATCH_DESC,
-      inputSchema: z.object({
-        calls: z
-          .array(z.object(CALL_INPUT_SCHEMA))
-          .min(1)
-          .max(10),
-        resultMode: z.enum(["mcp", "value"]).optional(),
-        timeoutMs: z.number().int().positive().optional(),
-        maxRetries: z.number().int().min(0).max(2).optional(),
-        diagnostics: z.boolean().optional(),
-      }),
-      // Same gate as call_tool: every call in the batch must be explicitly
-      // read-only or the batch is refused.
-      annotations: READ_ONLY_REMOTE,
-    },
-    async (args) => mt.batchCall(args as BatchArgs),
-  );
+  // Folded on the code-first surface: connecta.batch runs the same 1–10
+  // parallel read-only calls and returns the same typed per-call outcomes.
+  if (!codeFirst) {
+    server.registerTool(
+      "batch_call",
+      {
+        description: BATCH_DESC,
+        inputSchema: z.object({
+          calls: z
+            .array(z.object(CALL_INPUT_SCHEMA))
+            .min(1)
+            .max(10),
+          resultMode: z.enum(["mcp", "value"]).optional(),
+          timeoutMs: z.number().int().positive().optional(),
+          maxRetries: z.number().int().min(0).max(2).optional(),
+          diagnostics: z.boolean().optional(),
+        }),
+        // Same gate as call_tool: every call in the batch must be explicitly
+        // read-only or the batch is refused.
+        annotations: READ_ONLY_REMOTE,
+      },
+      async (args) => mt.batchCall(args as BatchArgs),
+    );
+  }
 }

package/src/operator-ui/browser.css

@@ -285,6 +285,69 @@
   .credential-field input { min-width: 0; width: 100%; }
   .danger { text-decoration-style: double; }
 
+  .token-create {
+    border-bottom: 1px solid var(--rule);
+    border-top: 1px solid var(--rule);
+    padding: .75rem 0;
+  }
+  .token-create > label {
+    display: block;
+    margin-bottom: .5rem;
+  }
+  .token-create input { flex: 1 1 18rem; }
+  .token-create button,
+  .token-card button,
+  .token-reveal button {
+    align-items: center;
+    display: inline-flex;
+    min-height: 2.75rem;
+  }
+  .token-reveal {
+    background: var(--ink);
+    color: var(--paper);
+    margin-top: 1.5rem;
+    padding: 1rem 1.25rem;
+  }
+  .token-reveal .meta,
+  .token-reveal .cap { color: #bbb; }
+  .token-reveal-head,
+  .token-card-head {
+    align-items: baseline;
+    display: flex;
+    flex-wrap: wrap;
+    gap: .25rem var(--gap);
+    justify-content: space-between;
+  }
+  .token-secret {
+    border-bottom: 1px solid #555;
+    border-top: 1px solid #555;
+    margin-top: .75rem;
+  }
+  .token-secret code {
+    color: var(--paper);
+    user-select: all;
+  }
+  .token-ledger {
+    border-bottom: 1px solid var(--rule);
+    margin-top: 1.5rem;
+  }
+  .token-card {
+    border-top: 1px solid var(--rule);
+    padding: .75rem 0 .75rem 1.25rem;
+    position: relative;
+  }
+  .token-card::before {
+    background: var(--ink);
+    bottom: 0;
+    content: "";
+    left: .25rem;
+    position: absolute;
+    top: 0;
+    width: 1px;
+  }
+  .token-card.revoked { color: var(--muted); }
+  .token-card.revoked::before { background: var(--rule); }
+
   details { margin-top: .75rem; }
   summary { cursor: pointer; list-style: none; width: max-content; }
   summary::-webkit-details-marker { display: none; }