Build the workspace
into your application.

Start with a tenant and a profile.

PulseGate brokers browser-delivered desktops from a dedicated workspace pool. Your application creates a session, attaches its display to a canvas, and closes the session when the user leaves.

1. Provision: agree on a region, concurrent capacity, desktop image, and corporate identity connection with the workspace team.
2. Authorize: have your application backend obtain a tenant-scoped, short-lived session credential after corporate SSO. Keep administrative credentials on the server.
3. Attach: create the regional session and initialize the browser client against the same assigned regional gateway.

The default profile can be set during onboarding. To select a profile explicitly, include its name in the session request.

curl -fsS -X POST \
  'https://gw-<region>.pulsegate.cloud/vdi/v1/session' \
  -H 'Authorization: Bearer <TENANT_TOKEN>' \
  -H 'Content-Type: application/json' \
  --data '{"profile":"contractor-engineering"}'

The session service returns HTTP 201 with a session identifier, expiry, approved display location, and workspace policy. A credential without a matching tenant scope receives HTTP 403.

Regional routing, without guesswork.

The corporate site serves documentation, public platform telemetry, and provisioning inquiries. Workspace admission, display delivery, and browser client distribution use the assigned regional services directly.

The coordinator publishes the service roles available in its cluster. Resolve those advertised locations instead of composing per-service hostnames. Residency policy can prevent admission even when another region has spare capacity.

Identity selects the workspace boundary.

Map corporate SAML or OIDC claims to a tenant workspace profile. Broker pools are dedicated to the tenant; the desktop’s writable root filesystem is ephemeral unless a separately approved managed volume is attached.

For cleanroom work, select a disposable image without a persistent volume. For financial workflows, match the desktop region and any managed storage to the same approved residency boundary.

Attach the web client to your page.

Import the regional ES module and give it an existing canvas. The client creates a session through the broker and reads the display location from the accepted session response.

<link rel="stylesheet"
  href="https://portal-<region>.pulsegate.cloud/portal/v1/client/theme.css">
<div class="vdi-container">
  <canvas id="viewport" class="vdi-canvas" tabindex="0"
    aria-label="Remote workspace display"></canvas>
</div>
<script type="module">
  import { WorkspaceSession } from
    'https://portal-<region>.pulsegate.cloud/portal/v1/client/client.js';

  const session = new WorkspaceSession({
    endpoint: 'https://gw-<region>.pulsegate.cloud',
    canvas: document.getElementById('viewport')
  });
  session.on('status', state => console.log(state));
  session.on('error', error => console.error(error.message));
  await session.connect('<TENANT_TOKEN>');
</script>

For cross-origin portal imports, allow your application origin during onboarding. The mirror must return the configured origin policy and serve JavaScript, CSS, and WebAssembly with their correct content types. Browser credentials are held in memory; this client does not write them to web storage.

Handle session events

session.on('status', state => updateConnectionLabel(state));
session.on('frame', ({ width, height }) => resizeWorkspaceFrame(width, height));
session.on('error', error => showWorkspaceError(error.message));

await session.sendInput({ type: 'key', key: 'Enter', action: 'down' });
await session.disconnect();

Only forward input when the workspace has focus. Bind clipboard and file UI to the policy returned by the broker, rather than inferring permission from browser capability.

Display decoding belongs in the browser.

The client uses the local H.264 WebAssembly decoder to render regional display frames to a canvas. The workspace image and data stay on the service side. Hardware-assisted browser graphics handle canvas presentation where available; WebAssembly itself is a software decoding path.

To initialize the decoder separately, load its matching import adapter and binary from the same regional release.

import { createH264Imports } from
  'https://portal-<region>.pulsegate.cloud/portal/v1/client/decoder.js';

const imports = createH264Imports();
const decoder = await WebAssembly.instantiateStreaming(
  fetch('https://portal-<region>.pulsegate.cloud/portal/v1/client/decoder-h264.wasm'),
  imports
);
console.log(decoder.instance.exports);

The bundled decoder is derived from the H.264 decoder published by h264decoder and its upstream h264bsd work. Release hashes and third-party notices ship beside the client. No native installer is needed on the user’s laptop.

Keep the browser boundary typed.

The client distribution includes declarations for session events, workspace policy, and lifecycle methods. Copy the declaration file into your application’s type sources when importing the module by URL.

import type { WorkspacePolicy, WorkspaceSessionOptions } from './client';

const options: WorkspaceSessionOptions = {
  endpoint: 'https://gw-<region>.pulsegate.cloud',
  canvas: document.querySelector<HTMLCanvasElement>('#viewport')!
};

const canExport = (policy: WorkspacePolicy): boolean =>
  policy.clipboard_out === true && policy.download === true;

Download client.d.ts. Session credentials should be supplied at runtime after your backend completes the identity exchange.

Create a session from Python.

The session service accepts a normal authenticated JSON request. Keep the tenant credential in your server’s secret store and pass it into your integration function.

import json
from urllib.request import Request, urlopen

def create_workspace(tenant_token):
    request = Request(
        'https://gw-<region>.pulsegate.cloud/vdi/v1/session',
        data=json.dumps({'profile': 'contractor-engineering'}).encode(),
        headers={
            'Authorization': 'Bearer ' + tenant_token,
            'Content-Type': 'application/json',
            'Accept': 'application/json',
        },
        method='POST',
    )
    with urlopen(request, timeout=10) as response:
        return json.load(response)

Do not retry a session-creation request after an ambiguous failure without checking the request reference with operations. Duplicate admission can reserve an extra desktop.

Use the standard Go HTTP client.

Set a bounded request timeout. Treat session admission as a state change, and inspect the status before reading the success schema.

func CreateWorkspace(ctx context.Context, token string) ([]byte, error) {
    payload := strings.NewReader(`{"profile":"contractor-engineering"}`)
    req, err := http.NewRequestWithContext(ctx, http.MethodPost,
        "https://gw-<region>.pulsegate.cloud/vdi/v1/session", payload)
    if err != nil { return nil, err }
    req.Header.Set("Authorization", "Bearer " + token)
    req.Header.Set("Content-Type", "application/json")
    client := &http.Client{Timeout: 10 * time.Second}
    res, err := client.Do(req)
    if err != nil { return nil, err }
    defer res.Body.Close()
    if res.StatusCode != http.StatusCreated {
        return nil, fmt.Errorf("workspace admission: HTTP %d", res.StatusCode)
    }
    return io.ReadAll(io.LimitReader(res.Body, 1 << 20))
}

Import context, fmt, io, net/http, strings, and time. Pass a tenant-scoped credential from your application’s secret store.

Discover and verify a client release.

The regional gateway publishes its client manifest. Resolve the regional mirror from this metadata, then verify the decoder’s SHA-256 before promoting a release inside your application.

const response = await fetch(
  'https://gw-<region>.pulsegate.cloud/portal/v1/client/manifest.json'
);
if (!response.ok) throw new Error('Client manifest unavailable');
const manifest = await response.json();
console.log(manifest.client_version, manifest.decoder.sha256);

Public bundle requests support read-only HTTP 200 responses and HTTP 206 range responses. Authentication is required for workspace creation and protected coordinator control. The corporate copy of the release manifest describes the same distribution; active desktops load their assets from the assigned regional mirror.

End the session, then clear the display.

Call await session.disconnect() when a user leaves or signs out. The client stops reading display frames, clears its canvas, and requests session closure. If the request cannot be delivered, the server-side expiry and idle policy still apply.

The broker revokes session-scoped credentials and disposes of the writable workspace layer. The browser client leaves no repository clone or downloaded desktop image. A profile that permits file export can create local files; closing a session cannot erase a file the user was allowed to download.

Keep administrative audit metadata separate from desktop contents. Your tenant agreement identifies which managed volumes, if any, survive a session.

Questions from implementation teams

Dedicated tenant provisioning

Self-service registration is closed. The workspace team provisions single-tenant capacity through an enterprise agreement, with a separate review of region, desktop images, and identity policy.