@phpsandbox/sdk 0.1.6 → 0.1.10

package/dist/integrations.d.ts

@@ -27,8 +27,6 @@ export declare class IntegrationApi {
     link(input: LinkIntegrationInput): Promise<Integration>;
     list(): Promise<Integration[]>;
     get(integration: IntegrationReference): Promise<Integration>;
-    update(integration: IntegrationReference, input: UpdateIntegrationInput): Promise<Integration>;
-    unlink(integration: IntegrationReference): Promise<void>;
 }
 export declare class Integration {
     readonly data: IntegrationData;

package/dist/integrations.js

@@ -14,13 +14,6 @@ export class IntegrationApi {
         const response = await this.client.get(`/integrations/${encodeURIComponent(integrationId(integration))}`);
         return new Integration(response.data, this.client);
     }
-    async update(integration, input) {
-        const response = await this.client.patch(`/integrations/${encodeURIComponent(integrationId(integration))}`, input);
-        return new Integration(response.data, this.client);
-    }
-    async unlink(integration) {
-        await this.client.delete(`/integrations/${encodeURIComponent(integrationId(integration))}`);
-    }
 }
 export class Integration {
     constructor(data, client) {
@@ -36,11 +29,12 @@ export class Integration {
     get label() {
         return this.data.label;
     }
-    update(input) {
-        return new IntegrationApi(this.client).update(this, input);
+    async update(input) {
+        const response = await this.client.patch(`/integrations/${encodeURIComponent(this.id)}`, input);
+        return new Integration(response.data, this.client);
     }
-    unlink() {
-        return new IntegrationApi(this.client).unlink(this);
+    async unlink() {
+        await this.client.delete(`/integrations/${encodeURIComponent(this.id)}`);
     }
 }
 export function integrationId(integration) {

package/dist/log.d.ts

@@ -3,8 +3,6 @@ import { RuntimeTelemetry, type RuntimeWatchOptions } from './runtime-telemetry.
 export interface LogEvents {
     'notebook.log': string;
 }
-export interface LogActions {
-}
 export interface RuntimeLogEntry {
     timestamp: string;
     source: 'runtime';

package/dist/lsp.js

@@ -30,7 +30,7 @@ export default class Lsp {
         return LspConnection.create(id, this);
     }
     whenSocketConnected() {
-        return this.okra.whenConnected();
+        return this.okra.connected();
     }
 }
 export class LspConnection {

package/dist/metrics.d.ts

@@ -1,10 +1,10 @@
 import type { NotebookInstance } from './index.js';
-import type { ContainerStats } from './container.js';
+import type { RuntimeStats } from './runtime.js';
 import { RuntimeTelemetry, type RuntimeWatchOptions } from './runtime-telemetry.js';
 export default class Metrics {
     private readonly okra;
     private readonly telemetry;
     constructor(okra: NotebookInstance, telemetry: RuntimeTelemetry);
-    current(): Promise<ContainerStats | null>;
-    watch(options?: RuntimeWatchOptions): ReadableStream<ContainerStats>;
+    current(): Promise<RuntimeStats | null>;
+    watch(options?: RuntimeWatchOptions): ReadableStream<RuntimeStats>;
 }

package/dist/ports.d.ts

@@ -1,5 +1,5 @@
 import type { NotebookInstance } from './index.js';
-import type { PortInfo } from './container.js';
+import type { PortInfo } from './runtime.js';
 import { RuntimeTelemetry, type RuntimeWatchOptions } from './runtime-telemetry.js';
 export default class Ports {
     private readonly okra;

package/dist/publications.d.ts

@@ -1,6 +1,6 @@
-import { type Client } from './index.js';
-import type { PublicationBuildStatus, PublicationDomainDnsRecordType, PublicationEventData, PublicationJurisdiction, PublicationLogChunkData, PublicationProtectionMode, PublicationRegion, PublicationReleaseStatus, PublicationSize, PublicationStatus, PublishStreamEvent, PublishStreamResult } from './schemas/publications.js';
-export * from './schemas/publications.js';
+import type { Client } from './index.js';
+import type { PublicationBuildStatus, PublicationEventData, PublicationJurisdiction, PublicationLogChunkData, PublicationProtectionMode, PublicationRegion, PublicationReleaseStatus, PublicationSize, PublicationStatus, PublishStreamEvent, PublishStreamResult } from './schemas/publications.js';
+export type { BuiltInPublicationProviderName, PublicationBuildStatus, PublicationEventData, PublicationJurisdiction, PublicationLogChunkData, PublicationLogStream, PublicationProtectionMode, PublicationRegion, PublicationReleaseStatus, PublicationSize, PublicationStatus, PublishStreamEvent, PublishStreamLog, PublishStreamPhase, PublishStreamResult, PublishStreamSseEvent, } from './schemas/publications.js';
 export interface PublicationPlacement {
     regions?: PublicationRegion[];
     jurisdiction?: PublicationJurisdiction;
@@ -66,7 +66,6 @@ export interface PublishInput<TName extends PublicationProviderName = Publicatio
     protection?: PublicationProtectionInput;
     metadata?: Record<string, unknown>;
 }
-export type PublicationRunResult = PublishStreamResult;
 export interface PublicationBuildData<TProvider extends PublicationProviderName = PublicationProviderName> {
     id: string;
     status: PublicationBuildStatus;
@@ -81,32 +80,6 @@ export interface PublicationReleaseData {
     status: PublicationReleaseStatus;
     manifest: Record<string, unknown>;
 }
-export interface PublicationDomainDnsData {
-    type: PublicationDomainDnsRecordType;
-    name: string;
-    value: string;
-}
-export interface PublicationDomainData {
-    id: string;
-    publicationId: string | null;
-    hostname: string;
-    status: string;
-    provider: string;
-    providerHostnameId: string | null;
-    dns: PublicationDomainDnsData;
-    ssl: {
-        status: string | null;
-    };
-    validationErrors: unknown[];
-    validationRecords: unknown[];
-    metadata: Record<string, unknown>;
-    verifiedAt: string | null;
-    createdAt: string | null;
-    updatedAt: string | null;
-}
-export interface CreatePublicationDomainInput {
-    hostname: string;
-}
 export interface PublicationData<TProvider extends PublicationProviderName = PublicationProviderName> {
     id: string;
     slug: string;
@@ -118,7 +91,6 @@ export interface PublicationData<TProvider extends PublicationProviderName = Pub
     eventStreamUrl: string | null;
     originUrl: string | null;
     currentRelease?: PublicationReleaseData | null;
-    domains?: PublicationDomainData[];
     latestBuild?: PublicationBuildData<TProvider> | null;
     deployedAt: string | null;
     createdAt: string | null;
@@ -134,28 +106,10 @@ export interface PublicationProtectionSessionData {
     expiresAt: string;
     url: string;
 }
-export declare class NotebookPublicationApi {
-    private readonly client;
-    constructor(client: Client);
-    current<TProvider extends PublicationProviderName = PublicationProviderName>(notebookId: string): Promise<PublicationInstance<TProvider> | null>;
-    publish<TProvider extends PublicationProviderName = PublicationProviderName>(notebookId: string, input?: PublishInput): Promise<PublicationRun<TProvider>>;
-}
 export declare class PublicationApi {
     private readonly client;
     constructor(client: Client);
     get<TProvider extends PublicationProviderName = PublicationProviderName>(id: string): Promise<PublicationInstance<TProvider>>;
-    destroy(id: string): Promise<void>;
-    setProtection<TProvider extends PublicationProviderName = PublicationProviderName>(id: string, input: UpdatePublicationProtectionInput): Promise<PublicationInstance<TProvider>>;
-    protection(id: string): Promise<PublicationProtectionData>;
-    createProtectionSession(id: string): Promise<PublicationProtectionSessionData>;
-    disableProtection<TProvider extends PublicationProviderName = PublicationProviderName>(id: string): Promise<PublicationInstance<TProvider>>;
-    listDomains(id: string): Promise<PublicationDomainData[]>;
-    createDomain(id: string, input: CreatePublicationDomainInput): Promise<PublicationDomainData>;
-    refreshDomain(id: string, domainId: string): Promise<PublicationDomainData>;
-    deleteDomain(id: string, domainId: string): Promise<void>;
-    events(id: string): Promise<ReadableStream<PublicationEventData>>;
-    buildLogs(id: string, buildId: string): Promise<ReadableStream<PublicationLogChunkData>>;
-    logs(id: string): Promise<ReadableStream<PublicationLogChunkData>>;
 }
 export declare class PublicationRun<TProvider extends PublicationProviderName = PublicationProviderName> {
     readonly initial: PublicationInstance<TProvider>;
@@ -171,7 +125,7 @@ export declare class PublicationRun<TProvider extends PublicationProviderName =
     private readonly subscribers;
     constructor(initial: PublicationInstance<TProvider>, client: Client);
     events(): AsyncIterable<PublishStreamEvent>;
-    result(): Promise<PublicationRunResult>;
+    result(): Promise<PublishStreamResult>;
     publication(): Promise<PublicationInstance<TProvider>>;
     start(): this;
     private subscribe;
@@ -199,8 +153,4 @@ export declare class PublicationInstance<TProvider extends PublicationProviderNa
     protection(): Promise<PublicationProtectionData>;
     createProtectionSession(): Promise<PublicationProtectionSessionData>;
     disableProtection(): Promise<PublicationInstance<TProvider>>;
-    domains(): Promise<PublicationDomainData[]>;
-    addDomain(input: CreatePublicationDomainInput): Promise<PublicationDomainData>;
-    refreshDomain(domainId: string): Promise<PublicationDomainData>;
-    deleteDomain(domainId: string): Promise<void>;
 }

package/dist/publications.js

@@ -1,29 +1,4 @@
-import { ApiError } from './index.js';
 import { PublicationEventDataSchema, PublicationLogChunkDataSchema, PublishStreamSseEventNameSchema, PublishStreamSseEventSchema, } from './schemas/publications.js';
-export * from './schemas/publications.js';
-export class NotebookPublicationApi {
-    constructor(client) {
-        this.client = client;
-    }
-    async current(notebookId) {
-        try {
-            const response = await this.client.get(`/notebook/${notebookId}/publication`);
-            return new PublicationInstance(response.data, this.client, notebookId);
-        }
-        catch (error) {
-            if (error instanceof ApiError && error.status === 404) {
-                return null;
-            }
-            throw error;
-        }
-    }
-    async publish(notebookId, input) {
-        const response = await this.client.post(`/notebook/${notebookId}/publication`, input);
-        const run = new PublicationRun(new PublicationInstance(response.data, this.client, notebookId), this.client);
-        run.start();
-        return run;
-    }
-}
 export class PublicationApi {
     constructor(client) {
         this.client = client;
@@ -32,49 +7,6 @@ export class PublicationApi {
         const response = await this.client.get(`/publications/${id}`);
         return new PublicationInstance(response.data, this.client);
     }
-    async destroy(id) {
-        await this.client.delete(`/publications/${id}`);
-    }
-    async setProtection(id, input) {
-        const response = await this.client.put(`/publications/${id}/protection`, input);
-        return new PublicationInstance(response.data, this.client);
-    }
-    async protection(id) {
-        const response = await this.client.get(`/publications/${id}/protection`);
-        return response.data;
-    }
-    async createProtectionSession(id) {
-        const response = await this.client.post(`/publications/${id}/protection/session`);
-        return response.data;
-    }
-    async disableProtection(id) {
-        const response = await this.client.delete(`/publications/${id}/protection`);
-        return new PublicationInstance(response.data, this.client);
-    }
-    async listDomains(id) {
-        const response = await this.client.get(`/publications/${id}/domains`);
-        return unwrapPublicationDomainCollection(response.data);
-    }
-    async createDomain(id, input) {
-        const response = await this.client.post(`/publications/${id}/domains`, input);
-        return response.data;
-    }
-    async refreshDomain(id, domainId) {
-        const response = await this.client.post(`/publications/${id}/domains/${domainId}/refresh`);
-        return response.data;
-    }
-    async deleteDomain(id, domainId) {
-        await this.client.delete(`/publications/${id}/domains/${domainId}`);
-    }
-    async events(id) {
-        return parseNdjsonStream(await this.client.stream(`/publications/${id}/events/stream`), PublicationEventDataSchema);
-    }
-    async buildLogs(id, buildId) {
-        return parseNdjsonStream(await this.client.stream(`/publications/${id}/builds/${buildId}/logs/stream`), PublicationLogChunkDataSchema);
-    }
-    async logs(id) {
-        return parseNdjsonStream(await this.client.stream(`/publications/${id}/logs/stream`), PublicationLogChunkDataSchema);
-    }
 }
 export class PublicationRun {
     constructor(initial, client) {
@@ -197,14 +129,17 @@ export class PublicationInstance {
         const response = await this.client.get(`/publications/${this.data.id}`);
         return new PublicationInstance(response.data, this.client, this.notebookId);
     }
-    publish() {
+    async publish() {
         if (!this.notebookId) {
             return Promise.reject(new Error('Publishing requires a notebook-scoped publication instance.'));
         }
-        return this.client.notebook.publication.publish(this.notebookId);
+        const response = await this.client.post(`/notebook/${this.notebookId}/publication`);
+        const run = new PublicationRun(new PublicationInstance(response.data, this.client, this.notebookId), this.client);
+        run.start();
+        return run;
     }
-    destroy() {
-        return this.client.publications.destroy(this.data.id);
+    async destroy() {
+        await this.client.delete(`/publications/${this.data.id}`);
     }
     async wait(options = {}) {
         const intervalMs = options.intervalMs ?? 1000;
@@ -220,41 +155,34 @@ export class PublicationInstance {
         }
         return current;
     }
-    events() {
-        return this.client.publications.events(this.data.id);
+    async events() {
+        return parseNdjsonStream(await this.client.stream(`/publications/${this.data.id}/events/stream`), PublicationEventDataSchema);
     }
     buildLogs(buildId = this.data.latestBuild?.id ?? '') {
         if (buildId === '') {
             return Promise.reject(new Error('Publication has no latest build id'));
         }
-        return this.client.publications.buildLogs(this.data.id, buildId);
+        return this.client.stream(`/publications/${this.data.id}/builds/${buildId}/logs/stream`)
+            .then((stream) => parseNdjsonStream(stream, PublicationLogChunkDataSchema));
     }
-    logs() {
-        return this.client.publications.logs(this.data.id);
+    async logs() {
+        return parseNdjsonStream(await this.client.stream(`/publications/${this.data.id}/logs/stream`), PublicationLogChunkDataSchema);
     }
-    setProtection(input) {
-        return this.client.publications.setProtection(this.data.id, input);
-    }
-    protection() {
-        return this.client.publications.protection(this.data.id);
-    }
-    createProtectionSession() {
-        return this.client.publications.createProtectionSession(this.data.id);
-    }
-    disableProtection() {
-        return this.client.publications.disableProtection(this.data.id);
-    }
-    domains() {
-        return this.client.publications.listDomains(this.data.id);
+    async setProtection(input) {
+        const response = await this.client.put(`/publications/${this.data.id}/protection`, input);
+        return new PublicationInstance(response.data, this.client, this.notebookId);
     }
-    addDomain(input) {
-        return this.client.publications.createDomain(this.data.id, input);
+    async protection() {
+        const response = await this.client.get(`/publications/${this.data.id}/protection`);
+        return response.data;
     }
-    refreshDomain(domainId) {
-        return this.client.publications.refreshDomain(this.data.id, domainId);
+    async createProtectionSession() {
+        const response = await this.client.post(`/publications/${this.data.id}/protection/session`);
+        return response.data;
     }
-    deleteDomain(domainId) {
-        return this.client.publications.deleteDomain(this.data.id, domainId);
+    async disableProtection() {
+        const response = await this.client.delete(`/publications/${this.data.id}/protection`);
+        return new PublicationInstance(response.data, this.client, this.notebookId);
     }
 }
 function publicationStatusIsTerminal(status) {
@@ -263,12 +191,6 @@ function publicationStatusIsTerminal(status) {
 function delay(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
-function unwrapPublicationDomainCollection(input) {
-    if (Array.isArray(input)) {
-        return input;
-    }
-    return Array.isArray(input.data) ? input.data : [];
-}
 class AsyncPublishEventQueue {
     constructor() {
         this.values = [];

package/dist/runtime/rest.js

@@ -1,13 +1,9 @@
-import { ErrorEvent } from '../types.js';
-import { UnsupportedRuntimeTransportError } from '../errors/index.js';
+import { PHPSandboxError, RemoteError, TransportError, remoteError } from '../errors/index.js';
 const restActionRoutes = {
     'runtime.ready': { method: 'GET', path: '/runtime' },
-    ping: { method: 'GET', path: '/runtime/ping' },
     'config.get': { method: 'GET', path: '/runtime/config' },
     'config.update': { method: 'PATCH', path: '/runtime/config' },
     'config.set-ports': { method: 'PUT', path: '/runtime/config/ports' },
-    'container.state': { method: 'GET', path: '/runtime/container' },
-    'container.start': { method: 'POST', path: '/runtime/container/start' },
     'container.restart': { method: 'POST', path: '/runtime/container/restart' },
     'container.stop': { method: 'POST', path: '/runtime/container/stop' },
     'container.set-php': { method: 'PUT', path: '/runtime/container/php' },
@@ -60,10 +56,15 @@ export class RestRuntimeInvoker {
         const actionUrl = new URL(runtimeUrl);
         const ticket = actionUrl.searchParams.get('ticket') ?? '';
         if (ticket === '') {
-            throw new UnsupportedRuntimeTransportError('The notebook connection does not contain a runtime ticket.');
+            throw new PHPSandboxError('The notebook connection does not contain a runtime ticket.');
         }
         this.ticket = ticket;
-        actionUrl.protocol = actionUrl.protocol === 'wss:' ? 'https:' : 'http:';
+        if (actionUrl.protocol === 'wss:') {
+            actionUrl.protocol = 'https:';
+        }
+        else if (actionUrl.protocol === 'ws:') {
+            actionUrl.protocol = 'http:';
+        }
         actionUrl.pathname = `/api/v1/notebooks/${encodeURIComponent(this.notebookId)}`;
         actionUrl.searchParams.delete('ticket');
         actionUrl.hash = '';
@@ -79,27 +80,28 @@ export class RestRuntimeInvoker {
         return this.invokeRaw(action, data ?? {}, options);
     }
     send() {
-        throw new UnsupportedRuntimeTransportError('Fire-and-forget actions require the realtime transport.');
+        throw new PHPSandboxError('Fire-and-forget actions require the realtime transport.');
     }
     async invokeRaw(action, data, options) {
         const abort = runtimeAbort(options);
         try {
             for (let attempt = 0; attempt < 2; attempt += 1) {
-                const response = await this.fetch(this.request(action, data, abort.signal));
+                const response = await runtimeFetch(this.fetch, this.request(action, data, abort.signal));
                 if (response.status === 401 && attempt === 0 && this.refresh !== undefined) {
                     await this.refreshAuthorization();
                     continue;
                 }
                 const payload = await runtimeActionResponse(response);
                 if (!response.ok || payload.error !== undefined) {
-                    const error = payload.error ?? payload;
-                    const message = typeof error.message === 'string' ? error.message : `Runtime action ${action} failed.`;
-                    const code = typeof error.code === 'number' ? error.code : response.status;
-                    throw new ErrorEvent(code, message, error);
+                    throw remoteError('runtime', payload.error, response);
                 }
                 return payload.data;
             }
-            throw new ErrorEvent(401, `Runtime action ${action} could not be authorized.`, {});
+            throw new RemoteError(`Runtime action ${action} could not be authorized.`, {
+                source: 'runtime',
+                status: 401,
+                code: 'AuthenticationRequired',
+            });
         }
         finally {
             abort.dispose();
@@ -108,7 +110,7 @@ export class RestRuntimeInvoker {
     request(action, data, signal) {
         const route = restActionRoutes[action];
         if (route === undefined) {
-            throw new UnsupportedRuntimeTransportError(`Runtime action ${action} requires the realtime transport.`);
+            throw new PHPSandboxError(`Runtime action ${action} requires the realtime transport.`);
         }
         const url = new URL(this.actionUrl);
         url.pathname += route.path;
@@ -122,6 +124,7 @@ export class RestRuntimeInvoker {
             headers,
             body: route.method === 'GET' ? undefined : body,
             signal,
+            redirect: 'error',
         });
     }
     async refreshAuthorization() {
@@ -136,19 +139,33 @@ export class RestRuntimeInvoker {
         }
     }
 }
+async function runtimeFetch(fetch, request) {
+    try {
+        return await fetch(request);
+    }
+    catch (error) {
+        if (error instanceof DOMException && error.name === 'AbortError') {
+            throw error;
+        }
+        throw new TransportError('Unable to reach the PHPSandbox runtime.', 'ConnectionFailed', error);
+    }
+}
 async function runtimeActionResponse(response) {
     if (response.ok && response.headers.get('content-type')?.toLowerCase().startsWith('application/octet-stream')) {
         return { data: new Uint8Array(await response.arrayBuffer()) };
     }
     const body = await response.text();
     if (body === '') {
+        if (response.ok) {
+            throw new TransportError('PHPSandbox runtime returned an empty response.', 'InvalidResponse', response);
+        }
         return {};
     }
     try {
         return JSON.parse(body);
     }
-    catch {
-        return { error: { code: response.status, message: body } };
+    catch (error) {
+        throw new TransportError('PHPSandbox runtime returned an invalid JSON response.', 'InvalidResponse', error);
     }
 }
 function runtimeActionRequestBody(action, data, url, headers) {

package/dist/runtime.d.ts

@@ -0,0 +1,68 @@
+import type { Action, NotebookInstance } from './index.js';
+import Logs, { type RuntimeLogEntry } from './log.js';
+import Metrics from './metrics.js';
+import Ports from './ports.js';
+import { type RuntimeTelemetryFeature, type RuntimeWatchOptions } from './runtime-telemetry.js';
+export interface PortInfo {
+    subdomain: string;
+    url: string;
+    default: boolean;
+    localPort?: number;
+    externalPort?: number;
+    port: number;
+}
+export interface RuntimeResourceUsage {
+    usage: number;
+    limit: number;
+}
+export interface RuntimeStats {
+    cpu: RuntimeResourceUsage;
+    memory: RuntimeResourceUsage;
+    disk: RuntimeResourceUsage;
+}
+export interface RuntimeEvents {
+    'container.stats': RuntimeStats;
+    'container.ports': PortInfo[];
+}
+export interface RuntimeActions {
+    'container.restart': Action<{}, void>;
+    'container.stop': Action<{}, void>;
+    'container.opened-ports': Action<{}, PortInfo[]>;
+    'container.stats': Action<{}, RuntimeStats | null>;
+    'container.set-php': Action<{
+        version: string;
+    }, {
+        version: string;
+    }>;
+    'container.stream-telemetry': Action<{
+        features: RuntimeTelemetryFeature[];
+    }, void>;
+    'container.stop-telemetry': Action<{}, void>;
+}
+export declare class RuntimeMetrics {
+    private readonly metrics;
+    constructor(metrics: Metrics);
+    current(): Promise<RuntimeStats | null>;
+    watch(options?: RuntimeWatchOptions): ReadableStream<RuntimeStats>;
+}
+export declare class RuntimeLogs {
+    private readonly logs;
+    constructor(logs: Logs);
+    follow(options?: RuntimeWatchOptions): ReadableStream<RuntimeLogEntry>;
+}
+export declare class RuntimePorts {
+    private readonly ports;
+    constructor(ports: Ports);
+    list(): Promise<PortInfo[]>;
+    watch(options?: RuntimeWatchOptions): ReadableStream<PortInfo[]>;
+}
+export default class Runtime {
+    private readonly notebook;
+    readonly metrics: RuntimeMetrics;
+    readonly logs: RuntimeLogs;
+    readonly ports: RuntimePorts;
+    constructor(notebook: NotebookInstance);
+    setPhpVersion(version: string): Promise<{
+        version: string;
+    }>;
+}

package/dist/runtime.js

@@ -0,0 +1,46 @@
+import Logs from './log.js';
+import Metrics from './metrics.js';
+import Ports from './ports.js';
+import { RuntimeTelemetry, } from './runtime-telemetry.js';
+export class RuntimeMetrics {
+    constructor(metrics) {
+        this.metrics = metrics;
+    }
+    current() {
+        return this.metrics.current();
+    }
+    watch(options = {}) {
+        return this.metrics.watch(options);
+    }
+}
+export class RuntimeLogs {
+    constructor(logs) {
+        this.logs = logs;
+    }
+    follow(options = {}) {
+        return this.logs.follow(options);
+    }
+}
+export class RuntimePorts {
+    constructor(ports) {
+        this.ports = ports;
+    }
+    list() {
+        return this.ports.list();
+    }
+    watch(options = {}) {
+        return this.ports.watch(options);
+    }
+}
+export default class Runtime {
+    constructor(notebook) {
+        this.notebook = notebook;
+        const telemetry = new RuntimeTelemetry(notebook);
+        this.metrics = new RuntimeMetrics(new Metrics(notebook, telemetry));
+        this.logs = new RuntimeLogs(new Logs(notebook, telemetry));
+        this.ports = new RuntimePorts(new Ports(notebook, telemetry));
+    }
+    setPhpVersion(version) {
+        return this.notebook.invoke('container.set-php', { version });
+    }
+}

package/dist/sandbox-integrations.d.ts

@@ -25,8 +25,6 @@ export declare class SandboxIntegrationApi {
     attach(input: AttachSandboxIntegrationInput): Promise<SandboxIntegration>;
     list(): Promise<SandboxIntegration[]>;
     get(integration: SandboxIntegrationReference): Promise<SandboxIntegration>;
-    update(integration: SandboxIntegrationReference, input: UpdateSandboxIntegrationInput): Promise<SandboxIntegration>;
-    detach(integration: SandboxIntegrationReference): Promise<void>;
     private path;
     private bindingPath;
 }
@@ -40,5 +38,6 @@ export declare class SandboxIntegration {
     get effects(): SandboxIntegrationEffect[];
     update(input: UpdateSandboxIntegrationInput): Promise<SandboxIntegration>;
     detach(): Promise<void>;
+    private path;
 }
 export declare function sandboxIntegrationId(integration: SandboxIntegrationReference): string;

package/dist/sandbox-integrations.js

@@ -19,16 +19,6 @@ export class SandboxIntegrationApi {
         const response = await this.client.get(this.bindingPath(integration));
         return new SandboxIntegration(response.data, this.notebookId, this.client);
     }
-    async update(integration, input) {
-        const response = await this.client.patch(this.bindingPath(integration), {
-            ...input,
-            integration: input.integration === undefined ? undefined : integrationId(input.integration),
-        });
-        return new SandboxIntegration(response.data, this.notebookId, this.client);
-    }
-    async detach(integration) {
-        await this.client.delete(this.bindingPath(integration));
-    }
     path() {
         return `/notebook/${this.notebookId}/integrations`;
     }
@@ -51,11 +41,18 @@ export class SandboxIntegration {
     get effects() {
         return this.data.effects;
     }
-    update(input) {
-        return new SandboxIntegrationApi(this.notebookId, this.client).update(this, input);
+    async update(input) {
+        const response = await this.client.patch(this.path(), {
+            ...input,
+            integration: input.integration === undefined ? undefined : integrationId(input.integration),
+        });
+        return new SandboxIntegration(response.data, this.notebookId, this.client);
+    }
+    async detach() {
+        await this.client.delete(this.path());
     }
-    detach() {
-        return new SandboxIntegrationApi(this.notebookId, this.client).detach(this);
+    path() {
+        return `/notebook/${this.notebookId}/integrations/${encodeURIComponent(this.id)}`;
     }
 }
 export function sandboxIntegrationId(integration) {