oblien 2.1.5 → 2.1.7

package/README.md

@@ -2,9 +2,9 @@
 
 Cloud workspaces that boot in milliseconds and run anything.
 
-Oblien gives you hardware-isolated microVMs -- each with its own kernel, its own memory, and full root access. Use them to give an AI agent a live environment, deploy a service with a public URL, run untrusted code in a throwaway sandbox, or spin up a dev machine you can SSH into. The workspace is the only primitive. What it becomes is up to you.
+Oblien gives you hardware-isolated microVMs — each with its own kernel, its own memory, and full root access. Use them to give an AI agent a live environment, deploy a service with a public URL, run untrusted code in a throwaway sandbox, or spin up a dev machine you can SSH into. The workspace is the only primitive. What it becomes is up to you.
 
-This is the official TypeScript SDK. It covers the full Oblien API surface: workspace lifecycle, networking, snapshots, workloads, metrics, SSH, public access, and the in-workspace runtime (files, exec, terminal, search, watchers, WebSocket).
+This is the official TypeScript SDK. It covers the full Oblien API surface.
 
 **Documentation:** [https://oblien.com/docs](https://oblien.com/docs)
 
@@ -12,23 +12,23 @@ This is the official TypeScript SDK. It covers the full Oblien API surface: work
 
 ## Platform
 
-Oblien is a workspace platform. Every workspace is a microVM that boots in under a second from any Docker image. Workspaces can be temporary (auto-delete after a TTL) or permanent (run indefinitely). They can be air-gapped or wired to other workspaces over a private internal network. They can expose ports to the internet through Oblien's edge proxy with automatic TLS -- or stay completely invisible.
+Oblien is a workspace platform. Every workspace is a microVM that boots in under a second from any Docker image. Workspaces can be temporary (auto-delete after a TTL) or permanent (run indefinitely). They can be air-gapped or wired to other workspaces over a private internal network. They can expose ports to the internet with automatic TLS — or stay completely invisible.
 
 The architecture is split into two planes:
 
-- **Control plane** (`api.oblien.com`) -- Create, configure, start, stop, snapshot, and destroy workspaces. Manage networking, firewall rules, SSH keys, workloads, images, billing, and metadata.
-- **Data plane** (`workspace.oblien.com`) -- Interact with a running workspace's filesystem, execute commands, open terminal sessions, watch files, and stream events over WebSocket.
+- **Control plane** (`api.oblien.com`) — Create, configure, start, stop, snapshot, and destroy workspaces. Manage networking, domains, pages, namespaces, and billing.
+- **Data plane** (`workspace.oblien.com`) — Interact with a running workspace's filesystem, execute commands, open terminal sessions, watch files, and stream events over WebSocket.
 
 The SDK wraps both planes in a single client.
 
 ### What people build with it
 
-- **AI agent environments** -- A permanent workspace is the agent's home. It creates short-lived sandboxes on demand for tasks, user code, or deployments.
-- **Service hosting** -- Run an API server, a queue worker, or a database as a permanent workspace. Map it to a custom domain.
-- **Remote development** -- SSH into a workspace, install your stack, expose a port for live preview.
-- **CI/CD** -- Spin up ephemeral workspaces per build, run tests in full isolation, auto-destroy when done.
-- **Code sandboxes** -- Air-gapped throwaway VMs that auto-delete after a TTL. No internet, no persistence.
-- **Per-user environments** -- One workspace per customer with scoped networking, credit quotas, and full isolation.
+- **AI agent environments** — A permanent workspace is the agent's home. It creates short-lived sandboxes on demand for tasks, user code, or deployments.
+- **Service hosting** — Run an API server, a queue worker, or a database. Map it to a custom domain.
+- **Static pages** — Deploy build output from a workspace to the edge CDN. No running VM required.
+- **Remote development** — SSH into a workspace, install your stack, expose a port for live preview.
+- **Per-user environments** — One workspace per customer with scoped networking, credit quotas, and full isolation.
+- **Enterprise routing** — Route subdomains to external upstreams through the edge proxy.
 
 ---
 
@@ -52,20 +52,16 @@ const client = new Oblien({
   clientSecret: process.env.OBLIEN_CLIENT_SECRET,
 });
 
-const ws = client.workspaces;
-
 // Create a workspace
-const workspace = await ws.create({
+const workspace = await client.workspaces.create({
   image: 'node-20',
   mode: 'permanent',
-  config: { cpus: 2, memory_mb: 4096 },
+  cpus: 2,
+  memory_mb: 4096,
 });
 
-// Start it
-await ws.start(workspace.id);
-
-// Connect to the runtime -- filesystem, exec, terminal
-const rt = await ws.runtime(workspace.id);
+// Connect to the runtime — filesystem, exec, terminal
+const rt = await client.workspaces.runtime(workspace.id);
 
 // Run a command
 const result = await rt.exec.run(['node', '--version']);
@@ -74,454 +70,188 @@ console.log(result.stdout);
 // Read a file
 const file = await rt.files.read({ filePath: '/etc/os-release' });
 console.log(file.content);
-
-// Expose port 3000 to the internet
-await ws.publicAccess.expose(workspace.id, { port: 3000 });
 ```
 
 ---
 
-## Architecture
-
-### Client and workspaces
+## SDK structure
 
-```typescript
-import Oblien from 'oblien';
-
-const client = new Oblien({ clientId, clientSecret });
-const ws = client.workspaces;
+```
+client
+├── workspaces          Control-plane workspace CRUD + power + sub-resources
+│   ├── lifecycle       Permanent/temporary mode, TTL, ping
+│   ├── network         Firewall, private links, outbound IP
+│   ├── ssh             SSH enable/disable, password/key
+│   ├── publicAccess    Expose ports with public URLs
+│   ├── domains         Custom domains with automatic SSL
+│   ├── resources       CPU, memory, disk allocation
+│   ├── snapshots       Snapshots and versioned archives
+│   ├── workloads       Managed background processes
+│   ├── metrics         Live stats, VM info/config
+│   ├── usage           Credit usage and activity tracking
+│   ├── metadata        Key-value metadata store
+│   ├── apiAccess       Runtime API tokens (gateway JWT / raw)
+│   ├── logs            Boot and command logs
+│   └── images          Available base images
+│
+├── pages               Static pages — deploy to the edge CDN from any workspace
+├── namespaces          Group workspaces, enforce resource limits and quotas
+├── edgeProxy           Enterprise reverse proxy — route subdomains to upstreams
+├── domain              Pre-flight checks — slug availability + DNS verification
+│
+└── workspace(id)       Scoped handle — all methods pre-filled with a workspace ID
 ```
 
-`client.workspaces` is the entry point for all control-plane operations. It provides CRUD methods, power controls, and 13 sub-resource namespaces:
+---
 
-| Namespace | Description |
-|-----------|-------------|
-| `ws.lifecycle` | Permanent/temporary mode, TTL, ping, destroy |
-| `ws.network` | Firewall rules, private links, outbound IP |
-| `ws.ssh` | Enable SSH, set password or public key |
-| `ws.publicAccess` | Expose and revoke public ports |
-| `ws.resources` | CPU, memory, disk allocation |
-| `ws.snapshots` | Create, restore, archive, and manage snapshots |
-| `ws.workloads` | Managed background processes with log streaming |
-| `ws.metrics` | Live CPU/memory/disk/network stats, VM info and config |
-| `ws.usage` | Credit usage, activity tracking |
-| `ws.metadata` | Key-value metadata store |
-| `ws.apiAccess` | Runtime API server -- enable, disable, rotate tokens |
-| `ws.logs` | Boot and command logs |
-| `ws.images` | Available workspace images |
-
-### CRUD
+## Workspaces
 
 ```typescript
-// Create
-const workspace = await ws.create({ image: 'node-20', mode: 'permanent' });
-
-// List
-const { workspaces } = await ws.list({ page: 1, limit: 20 });
-
-// Get
-const data = await ws.get('ws_a1b2c3d4');
-
-// Update
-await ws.update('ws_a1b2c3d4', { name: 'production-api' });
-
-// Delete
-await ws.delete('ws_a1b2c3d4');
-```
+const ws = client.workspaces;
 
-### Power controls
+// CRUD
+const workspace = await ws.create({ image: 'node-20' });
+const { workspaces } = await ws.list();
+const data = await ws.get(workspace.id);
+await ws.update(workspace.id, { name: 'my-api' });
+await ws.delete(workspace.id);
 
-```typescript
+// Power
 await ws.start(id);
 await ws.stop(id);
 await ws.restart(id);
-await ws.pause(id);    // preserves memory state
+await ws.pause(id);
 await ws.resume(id);
-await ws.ping(id);     // renews TTL for temporary workspaces
-```
-
-### Account-level queries
-
-```typescript
-const quota = await ws.getQuota();
-const estimate = await ws.getEstimate({ cpu: 4, ram_mb: 8192 });
-```
-
----
-
-## Runtime (data plane)
-
-The runtime connects to a running workspace and provides direct access to its filesystem, command execution, terminal sessions, search, and file watchers.
-
-```typescript
-const rt = await ws.runtime('ws_a1b2c3d4');
 ```
 
-This call enables the workspace's Runtime API server (if not already enabled), fetches a gateway JWT, and returns a `Runtime` instance. The token is cached -- subsequent calls for the same workspace return instantly.
-
-### Files
-
-```typescript
-// List directory
-const entries = await rt.files.list({ dirPath: '/app' });
-
-// Read file
-const { content } = await rt.files.read({ filePath: '/app/index.js' });
-
-// Write file
-await rt.files.write({ fullPath: '/app/config.json', content: '{}' });
+Sub-resources are accessed through namespaces on the workspaces object — `ws.lifecycle`, `ws.network`, `ws.domains`, etc. See the [API reference](https://oblien.com/docs/api) for full details on each.
 
-// Create directory
-await rt.files.mkdir({ path: '/app/logs' });
+### Scoped handle
 
-// Stat
-const stat = await rt.files.stat({ path: '/app/index.js' });
-
-// Delete
-await rt.files.delete({ path: '/app/tmp' });
-
-// Stream directory tree (async generator)
-for await (const entry of rt.files.stream({ dirPath: '/app' })) {
-  console.log(entry.path);
-}
-```
-
-### Exec
+Bind to a single workspace so you don't have to pass the ID every time:
 
 ```typescript
-// Run a command and wait for result
-const result = await rt.exec.run(['npm', 'test']);
-console.log(result.exitCode, result.stdout, result.stderr);
-
-// Stream output as it happens (async generator)
-for await (const event of rt.exec.stream(['npm', 'run', 'build'])) {
-  process.stdout.write(event.data);
-}
-
-// List running tasks
-const tasks = await rt.exec.list();
-
-// Kill a task
-await rt.exec.kill(taskId);
+const handle = client.workspace('ws_abc');
 
-// Send stdin to a running task
-await rt.exec.input(taskId, 'yes\n');
-
-// Subscribe to a running task's output
-for await (const event of rt.exec.subscribe(taskId)) {
-  console.log(event);
-}
+await handle.start();
+const rt = await handle.runtime();
+await rt.exec.run(['npm', 'test']);
+await handle.stop();
 ```
 
-### Terminal
-
-```typescript
-// Create a terminal session
-const session = await rt.terminal.create({ shell: '/bin/bash' });
-
-// List sessions
-const sessions = await rt.terminal.list();
-
-// Get scrollback buffer
-const { data } = await rt.terminal.scrollback(session.id, { bytes: 4096 });
+---
 
-// Close session
-await rt.terminal.close(session.id);
-```
+## Runtime (data plane)
 
-### Search
+The runtime connects to a running workspace and gives you direct access to its filesystem, command execution, terminal sessions, code search, and file watchers.
 
 ```typescript
-// Search file contents (ripgrep)
-const hits = await rt.search.content({ query: 'TODO', path: '/app' });
-
-// Search file names
-const files = await rt.search.files({ query: 'config', path: '/app' });
-
-// Index status and initialization
-const status = await rt.search.status();
-await rt.search.init();
+const rt = await client.workspaces.runtime('ws_abc');
 ```
 
-### Watcher
-
-```typescript
-// Watch a directory for changes
-const watcher = await rt.watcher.create({ path: '/app/src' });
-
-// List active watchers
-const watchers = await rt.watcher.list();
+This enables the Runtime API server (if needed), fetches a gateway JWT, and returns a `Runtime` instance. The token is cached — subsequent calls for the same workspace return instantly.
 
-// Get watcher info
-const info = await rt.watcher.get(watcher.id);
+| Namespace | What it does |
+|-----------|-------------|
+| `rt.files` | List, read, write, stat, mkdir, delete, stream directory trees |
+| `rt.exec` | Run commands, stream output, list/kill tasks, send stdin |
+| `rt.terminal` | Create PTY sessions, get scrollback, close sessions |
+| `rt.search` | Content search (ripgrep) and filename search |
+| `rt.watcher` | Watch directories for real-time file change events |
+| `rt.ws()` | WebSocket — persistent connection for terminal I/O and watcher events |
 
-// Stop watching
-await rt.watcher.delete(watcher.id);
-```
+See the [Runtime API docs](https://oblien.com/docs/runtime-api) for full endpoint reference.
 
 ---
 
-## WebSocket
+## Pages
 
-For real-time terminal I/O and file watcher events, open a persistent WebSocket connection:
+Deploy static files from a workspace to the edge CDN. The workspace can stop or be deleted after export — the page stays live with automatic TLS.
 
 ```typescript
-const socket = rt.ws();
-
-socket.onOpen(() => {
-  console.log('connected');
-});
-
-socket.onTerminalOutput((data) => {
-  process.stdout.write(data.output);
-});
-
-socket.onWatcherEvent((event) => {
-  console.log(event.type, event.path);
-});
-
-socket.onClose(() => {
-  console.log('disconnected');
+// Deploy a page
+const { page } = await client.pages.create({
+  workspace_id: 'ws_abc',
+  path: '/app/dist',
+  name: 'my-app',
 });
 
-socket.onError((err) => {
-  console.error(err);
+// Re-deploy with fresh files
+await client.pages.deploy(page.slug, {
+  workspace_id: 'ws_abc',
+  path: '/app/dist',
 });
 
-await socket.connect();
+// Custom domain
+await client.pages.connectDomain(page.slug, { domain: 'app.example.com' });
 
-// Send input to a terminal
-socket.writeTerminalInput(sessionId, 'ls -la\n');
-
-// Resize terminal
-socket.resizeTerminal(sessionId, { cols: 120, rows: 40 });
+// Toggle
+await client.pages.disable(page.slug);
+await client.pages.enable(page.slug);
 ```
 
----
-
-## SSE streaming
-
-Several endpoints return server-sent events as async generators. Consume them with `for await`:
-
-```typescript
-// Stream workspace logs
-for await (const line of ws.logs.streamBoot(id)) {
-  console.log(line);
-}
-
-// Stream workload output
-for await (const event of ws.workloads.logsStream(id, workloadId)) {
-  process.stdout.write(event.data);
-}
-
-// Stream live metrics
-for await (const snapshot of ws.metrics.statsStream(id)) {
-  console.log(snapshot.cpu_percent, snapshot.memory_used_mb);
-}
-
-// Stream workload stats
-for await (const stats of ws.workloads.statsStream(id, workloadId)) {
-  console.log(stats);
-}
-```
+See the [Pages docs](https://oblien.com/docs/concepts/pages) for concepts and the [Pages API](https://oblien.com/docs/api/pages) for the full reference.
 
 ---
 
-## Sub-resources
-
-### Lifecycle
-
-```typescript
-const status = await ws.lifecycle.get(id);
-
-// Convert to permanent
-await ws.lifecycle.makePermanent(id);
-
-// Convert to temporary with TTL
-await ws.lifecycle.makeTemporary(id, { ttl_seconds: 3600 });
-
-// Update TTL
-await ws.lifecycle.updateTtl(id, { ttl_seconds: 7200 });
-
-// Destroy (irreversible)
-await ws.lifecycle.destroy(id);
-```
+## Domains
 
-### Network
+Pre-flight checks before connecting custom domains or claiming slugs. These are standalone — not scoped to a specific workspace or page.
 
 ```typescript
-const network = await ws.network.get(id);
+// Check if a slug is available
+const { available, url } = await client.domain.checkSlug({ slug: 'my-app' });
 
-await ws.network.update(id, {
-  ingress: ['10.0.1.5'],
-  egress: ['10.0.1.10'],
-  allow_internet: false,
+// Verify DNS for a custom domain
+const { verified, cname, required_records } = await client.domain.verify({
+  domain: 'app.example.com',
+  resource_id: 'ws_abc',
 });
-
-// Assign a dedicated outbound IP
-await ws.network.applyOutboundIp(id, { ip: '203.0.113.50' });
 ```
 
-### SSH
+---
 
-```typescript
-await ws.ssh.enable(id, { password: 'secure-password' });
-await ws.ssh.enable(id, { publicKey: 'ssh-ed25519 AAAA...' });
-await ws.ssh.disable(id);
-const sshStatus = await ws.ssh.status(id);
-```
+## Namespaces
 
-### Public access
+Group workspaces into isolated namespaces with resource limits, spending quotas, and lifecycle controls.
 
 ```typescript
-// Expose a port
-const endpoint = await ws.publicAccess.expose(id, {
-  port: 3000,
-  domain: 'app.yourdomain.com',
+const ns = await client.namespaces.create({
+  name: 'production',
+  resource_limits: { max_workspaces: 50, max_cpus: 100 },
 });
 
-// List exposed ports
-const ports = await ws.publicAccess.list(id);
-
-// Revoke
-await ws.publicAccess.revoke(id, { port: 3000 });
-```
-
-### Snapshots
-
-```typescript
-// Create a snapshot
-await ws.snapshots.create(id, { label: 'before-deploy' });
-
-// Restore
-await ws.snapshots.restore(id);
-
-// Archives
-await ws.snapshots.createArchive(id, { label: 'v1.0' });
-const archives = await ws.snapshots.listArchives(id);
-const archive = await ws.snapshots.getArchive(id, 'v1');
-await ws.snapshots.deleteArchive(id, 'v1');
-await ws.snapshots.deleteAllArchives(id);
-```
-
-### Workloads
-
-```typescript
-// Create a managed workload
-await ws.workloads.create(id, {
-  name: 'server',
-  cmd: ['node', 'server.js'],
-  env: { PORT: '3000' },
+await client.namespaces.setQuota(ns.id, {
+  period: 'monthly',
+  max_credits: 500,
+  overdraft_action: 'stop',
 });
 
-const workloads = await ws.workloads.list(id);
-const workload = await ws.workloads.get(id, workloadId);
-await ws.workloads.start(id, workloadId);
-await ws.workloads.stop(id, workloadId);
-await ws.workloads.delete(id, workloadId);
-
-// Logs and stats (async generators)
-for await (const line of ws.workloads.logsStream(id, workloadId)) {
-  console.log(line);
-}
-for await (const snapshot of ws.workloads.statsStream(id, workloadId)) {
-  console.log(snapshot);
-}
+const { namespaces } = await client.namespaces.list();
 ```
 
-### Metrics
-
-```typescript
-const stats = await ws.metrics.stats(id);
-const info = await ws.metrics.info(id);
-const config = await ws.metrics.config(id);
-
-for await (const snapshot of ws.metrics.statsStream(id)) {
-  console.log(snapshot);
-}
-```
-
-### Usage
-
-```typescript
-const usage = await ws.usage.get(id);
-const totals = await ws.usage.totals(id);
-const chart = await ws.usage.creditsChart(id);
-const global = await ws.usage.global();
-const activity = await ws.usage.activity();
-await ws.usage.wipe(id);
-```
-
-### Metadata
-
-```typescript
-const meta = await ws.metadata.get(id);
-await ws.metadata.update(id, { key: 'env', value: 'production' });
-await ws.metadata.patch(id, { key: 'version', value: '2.1.0' });
-```
-
-### API access
-
-```typescript
-const status = await ws.apiAccess.status(id);
-const access = await ws.apiAccess.enable(id);
-await ws.apiAccess.disable(id);
-await ws.apiAccess.rotateToken(id);
-const token = await ws.apiAccess.getToken(id);
-const raw = await ws.apiAccess.rawToken(id);
-```
-
-### Logs
-
-```typescript
-const log = await ws.logs.get(id);
-await ws.logs.clear(id);
-const files = await ws.logs.listFiles(id);
-const file = await ws.logs.getFile(id, 'boot.log');
-
-for await (const line of ws.logs.streamBoot(id)) {
-  console.log(line);
-}
-for await (const line of ws.logs.streamCmd(id)) {
-  console.log(line);
-}
-```
-
-### Images
-
-```typescript
-const images = await ws.images.list();
-const image = await ws.images.get('node-20');
-```
+See the [Namespaces API](https://oblien.com/docs/api/namespaces) for the full reference.
 
 ---
 
-## Standalone imports
+## Edge Proxy
 
-The SDK exports `Workspace` and `Runtime` as standalone classes for cases where you need direct access without going through the main client:
+Enterprise-only reverse proxy — route subdomains to external upstreams through the edge.
 
 ```typescript
-// Workspace (control plane) -- standalone
-import { Workspace } from 'oblien/workspace';
-
-const ws = new Workspace(client);
-await ws.create({ image: 'python-3.12' });
-
-// Runtime (data plane) -- standalone with a raw token
-import { Runtime } from 'oblien/runtime';
-
-const rt = new Runtime({
-  token: 'your_gateway_jwt',
+const { proxy } = await client.edgeProxy.create({
+  name: 'staging-api',
+  slug: 'staging-api',
+  domain: 'edge.example.com',
+  target: 'https://internal-staging.example.com:8080',
 });
-await rt.files.list({ dirPath: '/' });
 
-// Runtime with a direct IP (bypass edge proxy)
-const directRt = new Runtime({
-  token: 'raw_token',
-  baseUrl: 'http://10.0.1.5:9990',
-});
+await client.edgeProxy.disable(proxy.id);
+await client.edgeProxy.enable(proxy.id);
 ```
 
+See the [Edge Proxy docs](https://oblien.com/docs/concepts/edge-proxy) for details.
+
 ---
 
 ## Error handling
@@ -529,44 +259,24 @@ const directRt = new Runtime({
 Every API error is an instance of `OblienError` with typed subclasses:
 
 ```typescript
-import Oblien, {
-  OblienError,
-  AuthenticationError,
-  NotFoundError,
-  RateLimitError,
-  ValidationError,
-  PaymentRequiredError,
-  ConflictError,
-} from 'oblien';
+import { NotFoundError, RateLimitError, PaymentRequiredError } from 'oblien';
 
 try {
-  await ws.get('ws_nonexistent');
+  await client.workspaces.get('ws_nonexistent');
 } catch (err) {
-  if (err instanceof NotFoundError) {
-    console.log('Workspace does not exist');
-  } else if (err instanceof AuthenticationError) {
-    console.log('Bad credentials');
-  } else if (err instanceof RateLimitError) {
-    console.log('Slow down -- retry after backoff');
-  } else if (err instanceof PaymentRequiredError) {
-    console.log('Quota exceeded -- upgrade your plan');
-  } else if (err instanceof ValidationError) {
-    console.log('Invalid parameters:', err.message);
-  } else if (err instanceof ConflictError) {
-    console.log('Workspace is in the wrong state for this operation');
-  } else if (err instanceof OblienError) {
-    console.log(`API error ${err.status}: ${err.message}`);
-  }
+  if (err instanceof NotFoundError) { /* 404 */ }
+  if (err instanceof RateLimitError) { /* 429 — back off */ }
+  if (err instanceof PaymentRequiredError) { /* 402 — quota exceeded */ }
 }
 ```
 
-| Error class | HTTP status | When |
-|-------------|-------------|------|
+| Error class | HTTP | When |
+|-------------|------|------|
 | `AuthenticationError` | 401 | Invalid or missing credentials |
 | `PaymentRequiredError` | 402 | Credit quota exceeded |
 | `NotFoundError` | 404 | Resource does not exist |
-| `ConflictError` | 409 | Resource in wrong state for the operation |
-| `ValidationError` | 422 | Invalid request parameters |
+| `ConflictError` | 409 | Resource in wrong state |
+| `ValidationError` | 422 | Invalid parameters |
 | `RateLimitError` | 429 | Too many requests |
 
 ---
@@ -581,29 +291,21 @@ const client = new Oblien({
 });
 ```
 
-| Option | Type | Default | Description |
-|--------|------|---------|-------------|
-| `clientId` | `string` | -- | Your API client ID |
-| `clientSecret` | `string` | -- | Your API client secret |
-| `baseUrl` | `string` | `https://api.oblien.com` | Control plane API base URL |
-
-Get your API keys from the [dashboard](https://oblien.com/dashboard).
+Get your API keys from the [dashboard](https://oblien.com/dashboard/settings).
 
 ---
 
 ## TypeScript
 
-The SDK is written in TypeScript and ships its own type declarations. All request parameters, response shapes, and event types are fully typed and exported from the top-level package:
+Written in TypeScript with full type declarations shipped. All request parameters, response shapes, and event types are exported:
 
 ```typescript
 import type {
-  WorkspaceCreateParams,
-  WorkspaceData,
-  ExecTask,
-  ExecStreamEvent,
-  FileEntry,
-  WSTerminalEvent,
-  WSWatcherEvent,
+  WorkspaceCreateParams, WorkspaceData,
+  PageCreateParams, PageData,
+  CheckSlugParams, VerifyDomainParams,
+  EdgeProxyCreateParams,
+  ExecStreamEvent, WSTerminalEvent,
 } from 'oblien';
 ```
 
@@ -620,12 +322,11 @@ import type {
 ## Links
 
 - [Documentation](https://oblien.com/docs)
-- [SDK setup guide](https://oblien.com/docs/workspace/sdk-setup)
 - [Quickstart](https://oblien.com/docs/workspace/quickstart)
+- [SDK setup guide](https://oblien.com/docs/workspace/sdk-setup)
 - [API reference](https://oblien.com/docs/api)
-- [Runtime / Runtime API](https://oblien.com/docs/runtime-api)
+- [Runtime API](https://oblien.com/docs/runtime-api)
 - [Dashboard](https://oblien.com/dashboard)
-- [GitHub](https://github.com/oblien/sdk)
 
 ---