@sandbox-kit/modal 0.0.0-stage → 0.1.1

package/dist/mappings/provider_mappings.d.ts

@@ -0,0 +1,14 @@
+import { type SandboxInfo, type Scope } from "@sandbox-kit/sandbox";
+import type { CreateOptions, OAuthCredentials, Resources, TokenPairCredentials } from "@sandbox-kit/sandbox";
+import type { ModalClientParams as NativeModalClientParams, Sandbox as NativeSandbox, SandboxCreateParams as NativeSandboxCreateParams } from "modal";
+type PublicLifetime = NonNullable<CreateOptions["lifetime"]>;
+type PublicIdleTerminate = NonNullable<PublicLifetime["idleTerminate"]>;
+export declare function mapSandboxIdentity(source: NativeSandbox | undefined, operation?: string): Partial<SandboxInfo>;
+export declare function mapClientScope(source: Scope | undefined, operation?: string): NativeModalClientParams;
+export declare function mapCommonCreateFields(source: CreateOptions | undefined, operation?: string): NativeSandboxCreateParams;
+export declare function mapResources(source: Resources | undefined, operation?: string): NativeSandboxCreateParams;
+export declare function mapLifetimeDuration(source: PublicLifetime | undefined, operation?: string): NativeSandboxCreateParams;
+export declare function mapIdleDuration(source: PublicIdleTerminate | undefined, operation?: string): NativeSandboxCreateParams;
+export declare function mapTokenPairCredentials(source: TokenPairCredentials | undefined, operation?: string): NativeModalClientParams;
+export declare function mapOAuthAuth(source: OAuthCredentials | undefined, operation?: string): NativeModalClientParams;
+export {};

package/dist/mappings/provider_mappings.js

@@ -0,0 +1,194 @@
+// Provider field mappings between shared CreateOptions/Config and the native SDK.
+// Inventoried in specs/providers/modal.yaml groups; kept in sync by hand (not emitted).
+import { ErrorKind, ValueOrigin, CreateFieldResourcesMemoryLimitMib, CreateFieldResourcesMemoryMib, InfoFieldId, CreateFieldLifetimeIdleTerminateAfter, CreateFieldLifetimeMaximumLifetime, CreateFieldResourcesCpuCores, CreateFieldResourcesCpuLimitCores, } from "@sandbox-kit/sandbox";
+import { providerError } from "#errors.js";
+export function mapSandboxIdentity(source, operation = "create") {
+    const target = {};
+    if (source === undefined)
+        return target;
+    const origins = {};
+    target.origins = origins;
+    {
+        if (source.sandboxId !== undefined) {
+            const value = source.sandboxId;
+            target.id = value;
+            origins[InfoFieldId] = ValueOrigin.Provider;
+        }
+    }
+    target.provider = "modal";
+    return target;
+}
+export function mapClientScope(source, operation = "initialize") {
+    const target = {};
+    if (source === undefined)
+        return target;
+    {
+        if (source.environment !== undefined) {
+            const value = source.environment;
+            target.environment = value;
+        }
+    }
+    return target;
+}
+export function mapCommonCreateFields(source, operation = "create") {
+    const target = {};
+    if (source === undefined)
+        return target;
+    {
+        if (source.name !== undefined) {
+            const value = source.name;
+            target.name = value;
+        }
+    }
+    {
+        if (source.environment !== undefined) {
+            const value = source.environment;
+            target.env = { ...value };
+        }
+    }
+    {
+        if (source.labels !== undefined) {
+            const value = source.labels;
+            target.tags = { ...value };
+        }
+    }
+    return target;
+}
+export function mapResources(source, operation = "create") {
+    const target = {};
+    if (source === undefined)
+        return target;
+    {
+        if (source.cpuCores !== undefined) {
+            target.cpu = scaledCpuCores(source.cpuCores, CreateFieldResourcesCpuCores, operation);
+        }
+    }
+    {
+        if (source.cpuLimitCores !== undefined) {
+            target.cpuLimit = scaledCpuCores(source.cpuLimitCores, CreateFieldResourcesCpuLimitCores, operation);
+        }
+    }
+    {
+        if (source.memoryMib !== undefined) {
+            const value = source.memoryMib;
+            if (value > 2147483647n)
+                mappingError({
+                    kind: ErrorKind.InvalidArgument,
+                    field: CreateFieldResourcesMemoryMib,
+                    message: "memory_mib cannot be represented",
+                    operation,
+                });
+            target.memoryMiB = Number(value);
+        }
+    }
+    {
+        if (source.memoryLimitMib !== undefined) {
+            const value = source.memoryLimitMib;
+            if (value > 2147483647n)
+                mappingError({
+                    kind: ErrorKind.InvalidArgument,
+                    field: CreateFieldResourcesMemoryLimitMib,
+                    message: "memory_limit_mib cannot be represented",
+                    operation,
+                });
+            target.memoryLimitMiB = Number(value);
+        }
+    }
+    return target;
+}
+export function mapLifetimeDuration(source, operation = "create") {
+    const target = {};
+    if (source === undefined)
+        return target;
+    {
+        if (source.maximumLifetime !== undefined) {
+            target.timeoutMs = durationSecondsMs(source.maximumLifetime, CreateFieldLifetimeMaximumLifetime, 86_400, operation);
+        }
+    }
+    return target;
+}
+export function mapIdleDuration(source, operation = "create") {
+    const target = {};
+    if (source === undefined)
+        return target;
+    {
+        if (source.after !== undefined) {
+            target.idleTimeoutMs = durationSecondsMs(source.after, CreateFieldLifetimeIdleTerminateAfter, 4_294_967_295, operation);
+        }
+    }
+    return target;
+}
+/** Modal CPU fields are millis-scaled: value must equal round(value*1000)/1000. */
+function scaledCpuCores(value, field, operation) {
+    const scaled = Math.round(value * 1000);
+    if (!Number.isFinite(value) ||
+        value < 0 ||
+        value !== scaled / 1000 ||
+        scaled > 4_294_967_295) {
+        mappingError({
+            kind: ErrorKind.InvalidArgument,
+            field,
+            message: field.slice(field.lastIndexOf(".") + 1) + " cannot be represented",
+            operation,
+        });
+    }
+    return value * 1000 < scaled ? scaled / 1000 : value;
+}
+/** Modal lifetime/idle timeouts are whole seconds expressed as milliseconds. */
+function durationSecondsMs(value, field, maximumSeconds, operation) {
+    if (!Number.isFinite(value) ||
+        value <= 0 ||
+        value % 1000 !== 0 ||
+        value / 1000 > maximumSeconds) {
+        mappingError({
+            kind: ErrorKind.InvalidArgument,
+            field,
+            message: field.slice(field.lastIndexOf(".") + 1) + " cannot be represented",
+            operation,
+        });
+    }
+    return value;
+}
+export function mapTokenPairCredentials(source, operation = "initialize") {
+    const target = {};
+    if (source === undefined)
+        return target;
+    {
+        const value = source.id;
+        target.tokenId = value;
+    }
+    {
+        const value = source.secret;
+        target.tokenSecret = value;
+    }
+    return target;
+}
+export function mapOAuthAuth(source, operation = "create") {
+    const target = {};
+    if (source === undefined)
+        return target;
+    {
+        const value = source.refreshToken;
+        target.oauthRefreshToken = value;
+    }
+    {
+        const value = source.clientId;
+        target.oauthClientId = value;
+    }
+    {
+        if (source.clientSecret !== undefined) {
+            const value = source.clientSecret;
+            target.oauthClientSecret = value;
+        }
+    }
+    {
+        if (source.jwtKey !== undefined) {
+            const value = source.jwtKey;
+            target.oauthJwtKey = value;
+        }
+    }
+    return target;
+}
+function mappingError(input) {
+    providerError(input);
+}

package/dist/mappings.d.ts

@@ -0,0 +1,17 @@
+import { type ModalClientParams, type Sandbox, type SandboxCreateParams } from "modal";
+import { type Config, type CreateOptions, type SandboxInfo } from "@sandbox-kit/sandbox";
+import type { ProviderState } from "./provider_config.js";
+export interface ModalCreatePlan {
+    readonly app: string;
+    readonly environment?: string;
+    readonly image: string;
+    readonly params: SandboxCreateParams;
+    readonly secretNames: readonly string[];
+    readonly proxyName?: string;
+    readonly waitUntilReady: boolean;
+    readonly readyTimeoutMs?: number;
+}
+export declare function mapClientConfig(config: Config): ModalClientParams;
+export declare function mapCreateRequest(request: CreateOptions, config: ProviderState): ModalCreatePlan;
+export declare function mapSandboxInfo(value: Sandbox, request?: CreateOptions): SandboxInfo;
+//# sourceMappingURL=mappings.d.ts.map

package/dist/mappings.js

@@ -0,0 +1,317 @@
+// Provider-specific orchestration around generated portable field mappings.
+import { Probe, } from "modal";
+import { EgressMode, ErrorKind, IsolationKind, PolicyMode, PortTransport, SecretInjection, SandboxState, ValueOrigin, WaitCondition, sandboxError } from "@sandbox-kit/sandbox";
+import { mapCommonCreateFields as generatedMapCommonCreateFields, mapIdleDuration as generatedMapIdleDuration, mapLifetimeDuration as generatedMapLifetimeDuration, mapResources as generatedMapResources, mapSandboxIdentity as generatedMapSandboxIdentity, } from "./provider_mappings.js";
+import { validateProviderCreate } from "./provider_checks.js";
+import { mapGeneratedClientConfig } from "./provider_config.js";
+export function mapClientConfig(config) {
+    const result = mapGeneratedClientConfig(config);
+    if (config.timeout !== undefined)
+        result.timeoutMs = finiteDurationMs(config.timeout, "timeout", true);
+    return result;
+}
+export function mapCreateRequest(request, config) {
+    validateProviderCreate(request);
+    const app = config.scope?.appName === undefined
+        ? invalid("scope.appName", "Modal app name is required")
+        : nonblank(config.scope.appName, "scope.appName");
+    if (request.source?.image === undefined)
+        unsupported("source", "Modal requires an explicit image source");
+    const params = generatedMapCommonCreateFields(request);
+    if (request.name !== undefined)
+        params.name = nonblank(request.name, "name");
+    if (config.region !== undefined)
+        params.regions = [nonblankConfig(config.region, "region")];
+    mapRuntime(request, params);
+    mapIsolation(request, params);
+    mapResources(request, params);
+    mapPlacement(request, params);
+    mapNetwork(request, params);
+    const secretNames = mapSecurity(request, params);
+    mapLifetime(request, params);
+    mapReadiness(request, params);
+    const wait = mapProvisioning(request, params);
+    mapObservability(request, params);
+    if (request.providerOptions !== undefined)
+        unsupported("providerOptions", "Modal provider options are not mapped");
+    return {
+        app,
+        ...(config.scope?.environment === undefined
+            ? {}
+            : { environment: config.scope.environment }),
+        image: nonblank(request.source.image.reference, "source.image.reference"),
+        params,
+        secretNames,
+        ...(request.network?.proxyReference === undefined
+            ? {}
+            : {
+                proxyName: nonblank(request.network.proxyReference, "network.proxyReference"),
+            }),
+        ...wait,
+    };
+}
+function mapRuntime(r, p) {
+    const v = r.runtime;
+    if (!v)
+        return;
+    if (v.workingDirectory !== undefined)
+        p.workdir = v.workingDirectory;
+    if (v.entrypoint !== undefined)
+        p.command = [...v.entrypoint];
+    if (v.pty !== undefined)
+        p.pty = v.pty;
+    if (v.language !== undefined ||
+        v.version !== undefined ||
+        v.user !== undefined)
+        unsupported("runtime", "language, version, and user must come from the Modal image");
+}
+function mapIsolation(r, p) {
+    const v = r.isolation;
+    if (!v)
+        return;
+    const kind = v.kind ?? IsolationKind.Default;
+    if (kind === IsolationKind.LinuxVm)
+        p.runtime = "vm";
+    else if (kind === IsolationKind.Container)
+        p.runtime = "gvisor";
+    else if (kind !== IsolationKind.Default)
+        unsupported("isolation.kind", "requested Modal isolation is unsupported");
+    if (v.providerKind !== undefined || v.nestedVirtualization !== undefined)
+        unsupported("isolation", "provider kind and nested virtualization are unsupported");
+}
+function mapResources(r, p) {
+    const v = r.resources;
+    if (!v)
+        return;
+    if (v.cpuLimitCores !== undefined)
+        positive(v.cpuLimitCores, "resources.cpuLimitCores");
+    if (v.memoryMib !== undefined)
+        integer(v.memoryMib, "resources.memoryMib", 128);
+    if (v.memoryLimitMib !== undefined)
+        integer(v.memoryLimitMib, "resources.memoryLimitMib", 1);
+    if (v.diskMib !== undefined)
+        unsupported("resources.diskMib", "Modal disk override is unsupported");
+    Object.assign(p, generatedMapResources(v));
+}
+function mapPlacement(r, p) {
+    const v = r.placement;
+    if (!v)
+        return;
+    if (v.cloud !== undefined)
+        p.cloud = v.cloud;
+    if (v.regions !== undefined)
+        p.regions = [...v.regions];
+    if (v.target !== undefined)
+        unsupported("placement.target", "Modal placement target is unsupported");
+}
+function mapNetwork(r, p) {
+    const v = r.network;
+    if (!v)
+        return;
+    const egress = v.egress ?? EgressMode.Default;
+    if (egress === EgressMode.BlockAll)
+        p.blockNetwork = true;
+    else if (egress !== EgressMode.Default &&
+        egress !== EgressMode.AllowAll &&
+        egress !== EgressMode.Restricted)
+        invalid("network.egress", "unknown egress mode");
+    if (v.outboundCidrs !== undefined)
+        p.outboundCidrAllowlist = [...v.outboundCidrs];
+    if (v.outboundDomains !== undefined)
+        p.outboundDomainAllowlist = [...v.outboundDomains];
+    if (v.inboundCidrs !== undefined) {
+        if (!v.inboundCidrs.length)
+            unsupported("network.inboundCidrs", "empty inbound deny-all is not representable");
+        p.inboundCidrAllowlist = [...v.inboundCidrs];
+    }
+    if (v.privateNetwork !== undefined)
+        p.i6pn = v.privateNetwork;
+    if (v.customDomain !== undefined)
+        p.customDomain = v.customDomain;
+    if (v.ports) {
+        p.encryptedPorts = [];
+        p.h2Ports = [];
+        p.unencryptedPorts = [];
+        for (const x of v.ports) {
+            const port = x.port;
+            if (port === undefined)
+                invalid("network.ports.port", "port is required");
+            const transport = x.transport ?? PortTransport.Default;
+            if (transport === PortTransport.Tls)
+                p.encryptedPorts.push(port);
+            else if (transport === PortTransport.Http2Tls)
+                p.h2Ports.push(port);
+            else if (transport === PortTransport.Plain)
+                p.unencryptedPorts.push(port);
+            else
+                invalid("network.ports.transport", "explicit transport is required");
+        }
+    }
+    if (v.linkedSandbox !== undefined || v.outboundProxyUrl !== undefined)
+        unsupported("network", "linked sandbox and outbound proxy URL mappings are unsupported");
+}
+function mapSecurity(r, p) {
+    const v = r.security;
+    if (!v)
+        return [];
+    if (v.workloadIdentity !== undefined)
+        p.includeOidcIdentityToken = v.workloadIdentity;
+    if (v.publicAccess !== undefined)
+        unsupported("security.publicAccess", "Modal public access is represented by ports");
+    const names = [];
+    for (const s of v.secrets ?? []) {
+        if (s.environmentVariable !== undefined)
+            unsupported("security.secrets.environmentVariable", "per-variable secret renaming is unsupported");
+        const injection = s.injection ?? SecretInjection.Default;
+        if (injection !== SecretInjection.Default &&
+            injection !== SecretInjection.Environment)
+            unsupported("security.secrets.injection", "egress-placeholder injection is unsupported");
+        names.push(nonblank(s.reference, "security.secrets.reference"));
+    }
+    return names;
+}
+function mapLifetime(r, p) {
+    const v = r.lifetime;
+    if (!v)
+        return;
+    if (v.maximumLifetime !== undefined)
+        finiteDurationMs(v.maximumLifetime, "lifetime.maximumLifetime", false);
+    Object.assign(p, generatedMapLifetimeDuration(v));
+    if (v.idleTerminate) {
+        const mode = v.idleTerminate.mode ?? PolicyMode.Default;
+        if (mode === PolicyMode.Disabled)
+            p.idleTimeoutMs = 0;
+        else if (mode === PolicyMode.After) {
+            if (v.idleTerminate.after === undefined)
+                invalid("lifetime.idleTerminate.after", "duration is required");
+            finiteDurationMs(v.idleTerminate.after, "lifetime.idleTerminate.after", false);
+            Object.assign(p, generatedMapIdleDuration(v.idleTerminate));
+        }
+        else if (mode !== PolicyMode.Default)
+            invalid("lifetime.idleTerminate.mode", "unknown policy mode");
+    }
+    if (v.ephemeral !== undefined ||
+        v.idleStop !== undefined ||
+        v.idlePause !== undefined ||
+        v.stoppedArchive !== undefined ||
+        v.stoppedDelete !== undefined)
+        unsupported("lifetime", "requested lifecycle policy is unsupported by Modal");
+}
+function mapReadiness(r, p) {
+    const v = r.readiness;
+    if (!v)
+        return;
+    if (v.tcpPort !== undefined) {
+        p.readinessProbe = Probe.withTcp(v.tcpPort);
+    }
+    else if (v.command !== undefined)
+        p.readinessProbe = Probe.withExec([...(v.command.argv ?? [])]);
+    else
+        invalid("readiness", "probe is required");
+}
+function mapProvisioning(r, _p) {
+    const v = r.provisioning;
+    if (!v)
+        return { waitUntilReady: false };
+    if (v.queueTimeout !== undefined)
+        unsupported("provisioning.queueTimeout", "Modal queue timeout is unsupported");
+    const waitFor = v.waitFor ?? WaitCondition.Default;
+    if (waitFor === WaitCondition.Default || waitFor === WaitCondition.Scheduled)
+        return { waitUntilReady: false };
+    if (waitFor === WaitCondition.Ready) {
+        if (v.timeout === undefined || v.timeout <= 0)
+            invalid("provisioning.timeout", "ready wait requires a positive timeout");
+        if (!r.readiness)
+            invalid("readiness", "ready wait requires a probe");
+        return { waitUntilReady: true, readyTimeoutMs: v.timeout };
+    }
+    unsupported("provisioning.waitFor", "requested wait condition is unsupported");
+}
+function mapObservability(r, p) {
+    const v = r.observability;
+    if (!v)
+        return;
+    if (v.verbose !== undefined)
+        p.verbose = v.verbose;
+    if (v.telemetryEndpoint !== undefined)
+        unsupported("observability.telemetryEndpoint", "per-sandbox telemetry endpoint is unsupported");
+}
+export function mapSandboxInfo(value, request) {
+    const mapped = generatedMapSandboxIdentity(value);
+    const origins = { ...(mapped.origins ?? {}) };
+    const result = {
+        id: mapped.id ?? value.sandboxId,
+        provider: "modal",
+        state: SandboxState.Running,
+        labels: {},
+        origins,
+    };
+    if (request?.name !== undefined) {
+        mutable(result).name = request.name;
+        origins.name = ValueOrigin.Request;
+    }
+    if (request?.labels !== undefined) {
+        mutable(result).labels = { ...request.labels };
+        origins.labels = ValueOrigin.Request;
+    }
+    if (request?.isolation !== undefined) {
+        mutable(result).isolation = { ...request.isolation };
+        origins.isolation = ValueOrigin.Request;
+    }
+    return result;
+}
+function mutable(v) {
+    return v;
+}
+function nonblank(v, f) {
+    if (!v.trim())
+        invalid(f, "must not be blank");
+    return v;
+}
+function nonblankConfig(v, f) {
+    if (!v.trim())
+        configInvalid(f, "must not be blank");
+    return v;
+}
+function positive(v, f) {
+    if (!Number.isFinite(v) || v <= 0)
+        invalid(f, "must be positive");
+    return v;
+}
+function integer(v, f, min) {
+    if (v < BigInt(min) || v > 2147483647n)
+        invalid(f, "is outside the supported range");
+    return Number(v);
+}
+function finiteDurationMs(v, f, zero) {
+    if (!Number.isFinite(v) || v < 0 || (!zero && v === 0))
+        invalid(f, "must be a finite positive duration");
+    return v;
+}
+function invalid(field, message) {
+    throw sandboxError({
+        kind: ErrorKind.InvalidArgument,
+        provider: "modal",
+        operation: "create",
+        field,
+        message: "sandbox-kit modal: " + message,
+    });
+}
+function unsupported(field, message) {
+    throw sandboxError({
+        kind: ErrorKind.Unsupported,
+        provider: "modal",
+        operation: "create",
+        field,
+        message: "sandbox-kit modal: " + message,
+    });
+}
+function configInvalid(field, message) {
+    throw sandboxError({
+        kind: ErrorKind.InvalidArgument,
+        provider: "modal",
+        operation: "initialize",
+        field,
+        message: "sandbox-kit modal: " + message,
+    });
+}

package/dist/modal.d.ts

@@ -0,0 +1,22 @@
+import { ModalClient, type ModalClientParams } from "modal";
+import { type Provider } from "@sandbox-kit/sandbox";
+import type { Backend, Config } from "@sandbox-kit/sandbox";
+import { ProviderBase } from "./provider.js";
+interface NativeModal {
+    readonly apps: Pick<ModalClient["apps"], "fromName">;
+    readonly images: Pick<ModalClient["images"], "fromRegistry">;
+    readonly proxies: Pick<ModalClient["proxies"], "fromName">;
+    readonly sandboxes: Pick<ModalClient["sandboxes"], "create" | "fromId">;
+    readonly secrets: Pick<ModalClient["secrets"], "fromName">;
+    close(): void;
+}
+type NativeFactory = (config: ModalClientParams) => NativeModal;
+/** @internal Exported for adapter boundary tests, but not from the package root. */
+export declare class ModalProvider extends ProviderBase {
+    private readonly nativeFactory;
+    constructor(nativeFactory?: NativeFactory);
+    initialize(config: Config): Backend;
+}
+/** Selects Modal as the provider for the shared Sandbox Kit client. */
+export declare function modal(): Provider;
+export {};

package/dist/modal.js

@@ -0,0 +1,106 @@
+import { ModalClient, } from "modal";
+import { LifecycleCapability, } from "@sandbox-kit/sandbox";
+import { mapClientConfig, mapCreateRequest, mapSandboxInfo, } from "#mappings/mappings.js";
+import { mapModalError } from "#errors.js";
+import { BackendBase, ProviderBase } from "./provider.js";
+import { captureProviderState, } from "#config/provider_config.js";
+/** @internal Exported for adapter boundary tests, but not from the package root. */
+export class ModalProvider extends ProviderBase {
+    nativeFactory;
+    constructor(nativeFactory = (config) => new ModalClient(config)) {
+        super();
+        this.nativeFactory = nativeFactory;
+    }
+    initialize(config) {
+        try {
+            return new ModalBackend(this.nativeFactory(mapClientConfig(config)), captureProviderState(config));
+        }
+        catch (error) {
+            throw mapModalError(error, "initialize");
+        }
+    }
+}
+class ModalBackend extends BackendBase {
+    native;
+    config;
+    constructor(native, config) {
+        super();
+        this.native = native;
+        this.config = config;
+    }
+    async create(request, options) {
+        try {
+            options.signal?.throwIfAborted();
+            const plan = mapCreateRequest(request, this.config);
+            const app = await this.native.apps.fromName(plan.app, {
+                ...(plan.environment === undefined
+                    ? {}
+                    : { environment: plan.environment }),
+            });
+            const secrets = await Promise.all(plan.secretNames.map((name) => this.native.secrets.fromName(name, {
+                ...(plan.environment === undefined
+                    ? {}
+                    : { environment: plan.environment }),
+            })));
+            const proxy = plan.proxyName === undefined
+                ? undefined
+                : await this.native.proxies.fromName(plan.proxyName, {
+                    ...(plan.environment === undefined
+                        ? {}
+                        : { environment: plan.environment }),
+                });
+            const image = this.native.images.fromRegistry(plan.image);
+            const sandbox = await this.native.sandboxes.create(app, image, {
+                ...plan.params,
+                ...(secrets.length === 0 ? {} : { secrets }),
+                ...(proxy === undefined ? {} : { proxy }),
+            });
+            if (plan.waitUntilReady) {
+                const readyTimeoutMs = plan.readyTimeoutMs ?? options.timeout;
+                await sandbox.waitUntilReady(readyTimeoutMs);
+            }
+            return { sandbox: mapSandboxInfo(sandbox, request) };
+        }
+        catch (error) {
+            throw mapModalError(error, "create");
+        }
+    }
+    async attach(id) {
+        try {
+            return mapSandboxInfo(await this.native.sandboxes.fromId(id));
+        }
+        catch (error) {
+            throw mapModalError(error, "attach");
+        }
+    }
+    capabilities() {
+        return [LifecycleCapability.Terminate];
+    }
+    async terminate(id, request) {
+        try {
+            const sandbox = await this.native.sandboxes.fromId(id);
+            if (request.wait === true)
+                return { exitCode: await sandbox.terminate({ wait: true }) };
+            await sandbox.terminate();
+            return {};
+        }
+        catch (error) {
+            throw mapModalError(error, "terminate");
+        }
+    }
+    async closeSandbox(id) {
+        try {
+            (await this.native.sandboxes.fromId(id)).detach();
+        }
+        catch (error) {
+            throw mapModalError(error, "close");
+        }
+    }
+    async close() {
+        this.native.close();
+    }
+}
+/** Selects Modal as the provider for the shared Sandbox Kit client. */
+export function modal() {
+    return new ModalProvider();
+}

package/dist/provider.checks.gen.d.ts

@@ -0,0 +1,3 @@
+import { type CreateOptionsWire } from "@sandbox-kit/sandbox";
+export declare function validateProviderCreate(request: CreateOptionsWire): void;
+//# sourceMappingURL=provider.checks.gen.d.ts.map