@vibesdotdev/infra-deploy 0.0.1 → 1.0.0-rc.4

package/dist/cli/workers/doks-worker-runtime.d.ts

@@ -0,0 +1,238 @@
+import { type RuntimeRef } from '@vibesdotdev/kernel';
+import { type JsonObject } from '@vibesdotdev/kernel/schemas/json';
+import { type WorkerDescriptor } from '@vibesdotdev/infra-core/kinds';
+import { z } from 'zod/v4';
+export declare const DoksWorkerDescriptorSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    hardware: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    enabled: z.ZodOptional<z.ZodBoolean>;
+    priority: z.ZodOptional<z.ZodNumber>;
+    capabilityId: z.ZodOptional<z.ZodString>;
+    requiredContext: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    optionalContext: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    retention: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        maxAgeDays: z.ZodOptional<z.ZodNumber>;
+        maxEntries: z.ZodOptional<z.ZodNumber>;
+        maxBytes: z.ZodOptional<z.ZodNumber>;
+        cascadeFrom: z.ZodOptional<z.ZodString>;
+        ageField: z.ZodOptional<z.ZodString>;
+        reason: z.ZodString;
+        enforcedBy: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>;
+    kind: z.ZodLiteral<"infra/worker">;
+    entrypoint: z.ZodOptional<z.ZodString>;
+    queues: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    concurrency: z.ZodOptional<z.ZodNumber>;
+    scaling: z.ZodOptional<z.ZodObject<{
+        min: z.ZodDefault<z.ZodNumber>;
+        max: z.ZodDefault<z.ZodNumber>;
+        cpu: z.ZodOptional<z.ZodString>;
+        memory: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    runtime: z.ZodOptional<z.ZodObject<{
+        scope: z.ZodObject<{
+            surface: z.ZodEnum<{
+                agent: "agent";
+                browser: "browser";
+                ssr: "ssr";
+                cli: "cli";
+                tui: "tui";
+                worker: "worker";
+                mcp: "mcp";
+                bridge: "bridge";
+            }>;
+            hardware: z.ZodEnum<{
+                consumer: "consumer";
+                cloud: "cloud";
+            }>;
+            purpose: z.ZodEnum<{
+                agent: "agent";
+                worker: "worker";
+                mcp: "mcp";
+                direct: "direct";
+                projection: "projection";
+            }>;
+            lifecycle: z.ZodEnum<{
+                finite: "finite";
+                persistent: "persistent";
+            }>;
+            hosting: z.ZodObject<{
+                mode: z.ZodUnion<readonly [z.ZodEnum<{
+                    local: "local";
+                    hosted: "hosted";
+                    "managed-cloud": "managed-cloud";
+                }>, z.ZodString]>;
+                owner: z.ZodUnion<readonly [z.ZodEnum<{
+                    consumer: "consumer";
+                    customer: "customer";
+                    vibes: "vibes";
+                }>, z.ZodString]>;
+                venue: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+                    "user-device": "user-device";
+                    "ipc-worker": "ipc-worker";
+                    doks: "doks";
+                    "cloudflare-workers": "cloudflare-workers";
+                    "digitalocean-functions": "digitalocean-functions";
+                }>, z.ZodString]>>;
+                provider: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+            qualifiers: z.ZodObject<{
+                dev: z.ZodBoolean;
+                building: z.ZodOptional<z.ZodBoolean>;
+                environmentTier: z.ZodOptional<z.ZodEnum<{
+                    local: "local";
+                    dev: "dev";
+                    staging: "staging";
+                    production: "production";
+                }>>;
+                profile: z.ZodOptional<z.ZodString>;
+                os: z.ZodOptional<z.ZodString>;
+                cef: z.ZodOptional<z.ZodBoolean>;
+                trustedOrigin: z.ZodOptional<z.ZodString>;
+                rendererGeneration: z.ZodOptional<z.ZodNumber>;
+                filesystem: z.ZodOptional<z.ZodString>;
+                browserBackend: z.ZodOptional<z.ZodString>;
+                workspaceSessionId: z.ZodOptional<z.ZodString>;
+                workspaceTarget: z.ZodOptional<z.ZodString>;
+                repositoryId: z.ZodOptional<z.ZodString>;
+                remoteHostId: z.ZodOptional<z.ZodString>;
+                connectionMode: z.ZodOptional<z.ZodString>;
+                outreachExportsDir: z.ZodOptional<z.ZodString>;
+                serve: z.ZodOptional<z.ZodString>;
+                hotReload: z.ZodOptional<z.ZodEnum<{
+                    on: "on";
+                    off: "off";
+                }>>;
+                loaderTimeoutMs: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>;
+            capabilities: z.ZodOptional<z.ZodObject<{
+                requestPrincipals: z.ZodOptional<z.ZodBoolean>;
+                interactiveSession: z.ZodOptional<z.ZodBoolean>;
+                hostCredentials: z.ZodOptional<z.ZodBoolean>;
+                sharedHost: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>>;
+            workspace: z.ZodOptional<z.ZodObject<{
+                root: z.ZodOptional<z.ZodString>;
+                access: z.ZodOptional<z.ZodEnum<{
+                    read: "read";
+                    write: "write";
+                }>>;
+            }, z.core.$strict>>;
+            tenancy: z.ZodOptional<z.ZodObject<{
+                ownerType: z.ZodEnum<{
+                    user: "user";
+                    organization: "organization";
+                    team: "team";
+                    system: "system";
+                }>;
+                ownerId: z.ZodString;
+                teamId: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            actor: z.ZodOptional<z.ZodObject<{
+                agentId: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>>;
+                harness: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>>;
+                agentSystemId: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>>;
+                harnessSessionId: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>>;
+                userId: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>>;
+                orgId: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>>;
+                projectId: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>>;
+                teamId: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>>;
+                home: z.ZodOptional<z.ZodEnum<{
+                    user: "user";
+                    organization: "organization";
+                    team: "team";
+                }>>;
+                projectIds: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>>>>;
+                participantId: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>>;
+                sessionId: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        adapter: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    env: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        public: z.ZodOptional<z.ZodBoolean>;
+        required: z.ZodOptional<z.ZodBoolean>;
+        value: z.ZodOptional<z.ZodString>;
+        secret: z.ZodOptional<z.ZodBoolean>;
+        description: z.ZodOptional<z.ZodString>;
+        storeKey: z.ZodOptional<z.ZodString>;
+        storeBinding: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    config: z.ZodOptional<z.ZodObject<{
+        adapter: z.ZodString;
+    }, z.core.$loose>>;
+}, z.core.$strip>;
+export type DoksWorkerDescriptor = WorkerDescriptor;
+export declare function admitWorkerDescriptor(descriptor: unknown): DoksWorkerDescriptor;
+export declare const DoksWorkerPlanSchema: z.ZodType<JsonObject, JsonObject, z.core.$ZodTypeInternals<JsonObject, JsonObject>>;
+export type DoksWorkerPlan = JsonObject;
+export declare function admitWorkerPlan(plan: unknown): DoksWorkerPlan;
+export declare const DoksWorkerStatusSchema: z.ZodObject<{
+    state: z.ZodEnum<{
+        failed: "failed";
+        pending: "pending";
+        succeeded: "succeeded";
+    }>;
+    reason: z.ZodString;
+    worker: z.ZodString;
+    operation: z.ZodEnum<{
+        build: "build";
+        apply: "apply";
+    }>;
+}, z.core.$strip>;
+export type DoksWorkerStatus = z.infer<typeof DoksWorkerStatusSchema>;
+export declare function admitWorkerStatus(status: unknown): DoksWorkerStatus;
+export interface DoksWorkerClient {
+    planApply(descriptor: DoksWorkerDescriptor): DoksWorkerPlan | Promise<DoksWorkerPlan>;
+    planBuild(descriptor: DoksWorkerDescriptor, sha: string): DoksWorkerPlan | Promise<DoksWorkerPlan>;
+    apply?(plan: DoksWorkerPlan): DoksWorkerPlan | Promise<DoksWorkerPlan>;
+    status?(plan: DoksWorkerPlan): DoksWorkerStatus | Promise<DoksWorkerStatus>;
+    create?(options?: {
+        environment?: string;
+    }): DoksWorkerClient | Promise<DoksWorkerClient>;
+}
+export interface DoksWorkerClientCandidate {
+    readonly planApply?: unknown;
+    readonly planBuild?: unknown;
+    readonly create?: unknown;
+    readonly apply?: unknown;
+    readonly status?: unknown;
+}
+export declare const DoksWorkerClientCandidateSchema: z.ZodType<DoksWorkerClientCandidate>;
+export declare const DoksWorkerOperationsSchema: z.ZodObject<{
+    planApply: z.ZodInstanceOf<Function>;
+    planBuild: z.ZodInstanceOf<Function>;
+}, z.core.$loose>;
+export declare const DoksWorkerClientSchema: z.ZodType<DoksWorkerClient>;
+export declare const DoksScopedOperationsSchema: z.ZodObject<{
+    apply: z.ZodInstanceOf<Function>;
+    status: z.ZodInstanceOf<Function>;
+}, z.core.$loose>;
+export declare function admitWorkerClient(client: unknown): DoksWorkerClient;
+/**
+ * The declared DOKS workers, read from the registry. The boot's one discovery
+ * pass registered every `infra/worker` descriptor its kind's patterns match
+ * (`*.infra.ts`, `infra/*.infra.ts`) in each declared package of the bound
+ * workspace; the command runs no discovery of its own.
+ */
+export declare function selectDoksWorkers(runtime: Pick<RuntimeRef, 'query'>, requested: readonly string[]): DoksWorkerDescriptor[];
+export declare function resolveDoksWorkerClient(runtime: Pick<RuntimeRef, 'query' | 'hasKind'>, options: {
+    adapter?: string;
+    environment?: string;
+    mutate: boolean;
+}): Promise<DoksWorkerClient>;
+export declare function waitForDoksWorker(client: DoksWorkerClient, plan: DoksWorkerPlan, options: {
+    /** The runtime whose lifecycle owns the status deadline and the poll pauses. */
+    runtime: Pick<RuntimeRef, 'lifecycle'>;
+    timeoutMs: number;
+    pollIntervalMs?: number;
+    onStatus?: (status: DoksWorkerStatus) => void;
+    sleep?: (ms: number) => Promise<void>;
+}): Promise<DoksWorkerStatus>;
+export declare function applyAndWaitForDoksWorker(client: DoksWorkerClient, plan: DoksWorkerPlan, options: Parameters<typeof waitForDoksWorker>[2]): Promise<DoksWorkerStatus>;
+export declare function printWorkerPlan(runtime: Pick<RuntimeRef, 'hasKind' | 'query'>, plan: DoksWorkerPlan): Promise<void>;
+//# sourceMappingURL=doks-worker-runtime.d.ts.map

package/dist/cli/workers/doks-worker-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"doks-worker-runtime.d.ts","sourceRoot":"","sources":["../../../src/cli/workers/doks-worker-runtime.ts"],"names":[],"mappings":"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"}

package/dist/cli/workers/doks-worker-runtime.js

@@ -0,0 +1,410 @@
+import { CapabilityError, CaughtFailureSchema, settle, getRuntimeStdio, valueFreeFailure } from '@vibesdotdev/kernel';
+import { JsonObjectSchema } from '@vibesdotdev/kernel/schemas/json';
+import { WorkerDescriptorSchema } from '@vibesdotdev/infra-core/kinds';
+import { z } from 'zod/v4';
+export const DoksWorkerDescriptorSchema = WorkerDescriptorSchema;
+export function admitWorkerDescriptor(descriptor) {
+    try {
+        const parsed = DoksWorkerDescriptorSchema.safeParse(descriptor);
+        if (!parsed.success) {
+            throw new CapabilityError('Invalid DOKS worker descriptor structure.', 'INVALID_INPUT', {
+                cause: valueFreeFailure(CaughtFailureSchema.parse(parsed.error))
+            });
+        }
+        return parsed.data;
+    }
+    catch (cause) {
+        if (cause instanceof CapabilityError)
+            throw cause;
+        throw new CapabilityError('DOKS worker descriptor validation threw an unexpected error.', 'INVALID_INPUT', {
+            cause: valueFreeFailure(CaughtFailureSchema.parse(cause))
+        });
+    }
+}
+export const DoksWorkerPlanSchema = JsonObjectSchema;
+export function admitWorkerPlan(plan) {
+    try {
+        const parsed = DoksWorkerPlanSchema.safeParse(plan);
+        if (!parsed.success) {
+            throw new CapabilityError('Invalid DOKS worker plan structure.', 'INVALID_INPUT', {
+                cause: valueFreeFailure(CaughtFailureSchema.parse(parsed.error))
+            });
+        }
+        return parsed.data;
+    }
+    catch (cause) {
+        if (cause instanceof CapabilityError)
+            throw cause;
+        throw new CapabilityError('DOKS worker plan validation threw an unexpected error.', 'INVALID_INPUT', {
+            cause: valueFreeFailure(CaughtFailureSchema.parse(cause))
+        });
+    }
+}
+export const DoksWorkerStatusSchema = z.object({
+    state: z.enum(['pending', 'succeeded', 'failed']),
+    reason: z.string(),
+    worker: z.string(),
+    operation: z.enum(['build', 'apply'])
+});
+export function admitWorkerStatus(status) {
+    try {
+        const parsed = DoksWorkerStatusSchema.safeParse(status);
+        if (!parsed.success) {
+            throw new CapabilityError('Invalid DOKS worker status structure.', 'INVALID_INPUT', {
+                cause: valueFreeFailure(CaughtFailureSchema.parse(parsed.error))
+            });
+        }
+        return parsed.data;
+    }
+    catch (cause) {
+        if (cause instanceof CapabilityError)
+            throw cause;
+        throw new CapabilityError('DOKS worker status validation threw an unexpected error.', 'INVALID_INPUT', {
+            cause: valueFreeFailure(CaughtFailureSchema.parse(cause))
+        });
+    }
+}
+const FunctionSchema = z.instanceof(Function);
+export const DoksWorkerClientCandidateSchema = z.custom((val) => val instanceof Object);
+export const DoksWorkerOperationsSchema = z
+    .object({
+    planApply: z.instanceof(Function),
+    planBuild: z.instanceof(Function)
+})
+    .passthrough();
+export const DoksWorkerClientSchema = z.custom((val) => {
+    const parsed = DoksWorkerClientCandidateSchema.safeParse(val);
+    if (!parsed.success)
+        return false;
+    return (FunctionSchema.safeParse(parsed.data.planApply).success &&
+        FunctionSchema.safeParse(parsed.data.planBuild).success);
+});
+export const DoksScopedOperationsSchema = z
+    .object({
+    apply: z.instanceof(Function),
+    status: z.instanceof(Function)
+})
+    .passthrough();
+const originalReceivers = new WeakMap();
+function resolveReceiver(target) {
+    return originalReceivers.get(target) ?? target;
+}
+export function admitWorkerClient(client) {
+    let rawClient;
+    try {
+        const parsed = DoksWorkerClientCandidateSchema.safeParse(client);
+        if (!parsed.success) {
+            throw new CapabilityError('The worker adapter client must be an object.', 'INVALID_INPUT', {
+                reason: 'doks-worker-client-invalid',
+                cause: valueFreeFailure(CaughtFailureSchema.parse(parsed.error))
+            });
+        }
+        rawClient = parsed.data;
+    }
+    catch (cause) {
+        if (cause instanceof CapabilityError)
+            throw cause;
+        throw new CapabilityError('The worker adapter client property check failed.', 'INVALID_INPUT', {
+            reason: 'doks-worker-client-invalid',
+            cause: valueFreeFailure(CaughtFailureSchema.parse(cause))
+        });
+    }
+    let planApplyFn;
+    let planBuildFn;
+    try {
+        planApplyFn = rawClient.planApply;
+        planBuildFn = rawClient.planBuild;
+    }
+    catch (cause) {
+        if (cause instanceof CapabilityError)
+            throw cause;
+        throw new CapabilityError('The worker adapter client property check failed.', 'INVALID_INPUT', {
+            reason: 'doks-worker-client-invalid',
+            cause: valueFreeFailure(CaughtFailureSchema.parse(cause))
+        });
+    }
+    const parsedPlanApply = FunctionSchema.safeParse(planApplyFn);
+    const parsedPlanBuild = FunctionSchema.safeParse(planBuildFn);
+    if (!parsedPlanApply.success || !parsedPlanBuild.success) {
+        throw new CapabilityError('The worker adapter client must expose planApply and planBuild operations.', 'INVALID_INPUT', {
+            reason: 'doks-worker-client-invalid'
+        });
+    }
+    const boundPlanApplyCallable = parsedPlanApply.data;
+    const boundPlanBuildCallable = parsedPlanBuild.data;
+    const boundPlanApply = async (descriptor) => {
+        let result;
+        try {
+            result = await boundPlanApplyCallable.call(rawClient, descriptor);
+        }
+        catch (error) {
+            if (error instanceof CapabilityError)
+                throw error;
+            throw new CapabilityError('DOKS worker planApply operation failed.', 'INTERNAL', { cause: valueFreeFailure(CaughtFailureSchema.parse(error)) });
+        }
+        return admitWorkerPlan(result);
+    };
+    const boundPlanBuild = async (descriptor, sha) => {
+        let result;
+        try {
+            result = await boundPlanBuildCallable.call(rawClient, descriptor, sha);
+        }
+        catch (error) {
+            if (error instanceof CapabilityError)
+                throw error;
+            throw new CapabilityError('DOKS worker planBuild operation failed.', 'INTERNAL', { cause: valueFreeFailure(CaughtFailureSchema.parse(error)) });
+        }
+        return admitWorkerPlan(result);
+    };
+    const admitted = Object.create(rawClient, {
+        planApply: {
+            value: boundPlanApply,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        },
+        planBuild: {
+            value: boundPlanBuild,
+            enumerable: true,
+            configurable: true,
+            writable: true
+        }
+    });
+    originalReceivers.set(admitted, rawClient);
+    originalReceivers.set(rawClient, rawClient);
+    return admitted;
+}
+/**
+ * The declared DOKS workers, read from the registry. The boot's one discovery
+ * pass registered every `infra/worker` descriptor its kind's patterns match
+ * (`*.infra.ts`, `infra/*.infra.ts`) in each declared package of the bound
+ * workspace; the command runs no discovery of its own.
+ */
+export function selectDoksWorkers(runtime, requested) {
+    const rawDescriptors = runtime.query('infra/worker').descriptors();
+    const available = rawDescriptors
+        .map(admitWorkerDescriptor)
+        .filter((descriptor) => descriptor.config !== undefined);
+    const selected = requested.length === 0
+        ? available
+        : requested
+            .map((id) => available.find((descriptor) => descriptor.id === id))
+            .filter((descriptor) => descriptor !== undefined);
+    const missing = requested.filter((id) => !selected.some((descriptor) => descriptor.id === id));
+    if (missing.length > 0) {
+        throw new CapabilityError(`Worker descriptor(s) not found: ${missing.join(', ')}`, 'NOT_FOUND');
+    }
+    if (selected.length === 0) {
+        throw new CapabilityError('No infra/worker descriptors declare an adapter.', 'NOT_FOUND');
+    }
+    return selected;
+}
+export async function resolveDoksWorkerClient(runtime, options) {
+    const registeredClients = runtime.query('runtime/client').descriptors();
+    const adapterId = options.adapter ?? (registeredClients.length === 1 ? registeredClients[0]?.id : undefined);
+    if (!adapterId) {
+        throw new CapabilityError(registeredClients.length === 0
+            ? 'No worker runtime client is registered.'
+            : 'Select the worker adapter declared by the descriptor.', registeredClients.length === 0 ? 'NOT_FOUND' : 'INVALID_INPUT', { reason: registeredClients.length === 0 ? 'doks-worker-client-absent' : 'worker-adapter-ambiguous' });
+    }
+    let base;
+    try {
+        if (runtime.hasKind('infra/worker')) {
+            const worker = await settle(() => runtime.query('infra/worker').withId(adapterId).resolve());
+            if (worker.ok) {
+                base = worker.value;
+            }
+            else if (!CapabilityError.isAbsenceOf(worker.cause, 'infra/worker', adapterId)) {
+                throw worker.cause;
+            }
+        }
+        if (base == null) {
+            base = await runtime.query('runtime/client').withId(adapterId).resolve();
+        }
+    }
+    catch (error) {
+        if (error instanceof CapabilityError) {
+            if (error.code === 'NOT_FOUND' &&
+                (!error.reason || error.reason === 'doks-worker-client-absent' || error.reason === 'descriptor-not-found' || error.reason === 'not-registered')) {
+                throw new CapabilityError('The worker adapter client is absent.', 'NOT_FOUND', {
+                    reason: 'doks-worker-client-absent',
+                    cause: valueFreeFailure(CaughtFailureSchema.parse(error))
+                });
+            }
+            throw error;
+        }
+        throw new CapabilityError('Failed to resolve worker adapter client.', 'INTERNAL', {
+            cause: valueFreeFailure(CaughtFailureSchema.parse(error))
+        });
+    }
+    if (base == null) {
+        throw new CapabilityError('The worker adapter client is absent.', 'NOT_FOUND', {
+            reason: 'doks-worker-client-absent'
+        });
+    }
+    const admittedBase = admitWorkerClient(base);
+    if (!options.mutate)
+        return admittedBase;
+    const baseReceiver = resolveReceiver(admittedBase);
+    let createFn;
+    try {
+        createFn = Object.hasOwn(admittedBase, 'create') ? admittedBase.create : baseReceiver.create;
+    }
+    catch (cause) {
+        if (cause instanceof CapabilityError)
+            throw cause;
+        throw new CapabilityError('The worker adapter client cannot create a credentialed execution scope.', 'INVALID_INPUT', {
+            reason: 'doks-worker-client-cannot-create',
+            cause: valueFreeFailure(CaughtFailureSchema.parse(cause))
+        });
+    }
+    const parsedCreate = FunctionSchema.safeParse(createFn);
+    if (!parsedCreate.success) {
+        throw new CapabilityError('The worker adapter client cannot create a credentialed execution scope.', 'NOT_FOUND', {
+            reason: 'doks-worker-client-cannot-create'
+        });
+    }
+    let scoped;
+    try {
+        scoped = await parsedCreate.data.call(baseReceiver, { environment: options.environment });
+    }
+    catch (cause) {
+        if (cause instanceof CapabilityError)
+            throw cause;
+        throw new CapabilityError('Failed to create credentialed execution scope.', 'INTERNAL', {
+            cause: valueFreeFailure(CaughtFailureSchema.parse(cause))
+        });
+    }
+    if (scoped == null) {
+        throw new CapabilityError('The credentialed worker adapter client is absent.', 'NOT_FOUND', {
+            reason: 'doks-worker-client-absent'
+        });
+    }
+    const admittedScoped = admitWorkerClient(scoped);
+    const scopedReceiver = resolveReceiver(admittedScoped);
+    let applyFn;
+    let statusFn;
+    try {
+        applyFn = Object.hasOwn(admittedScoped, 'apply') ? admittedScoped.apply : scopedReceiver.apply;
+        statusFn = Object.hasOwn(admittedScoped, 'status') ? admittedScoped.status : scopedReceiver.status;
+    }
+    catch (cause) {
+        if (cause instanceof CapabilityError)
+            throw cause;
+        throw new CapabilityError('The credentialed worker adapter client failed schema validation.', 'INVALID_INPUT', {
+            cause: valueFreeFailure(CaughtFailureSchema.parse(cause))
+        });
+    }
+    const parsedApply = FunctionSchema.safeParse(applyFn);
+    const parsedStatus = FunctionSchema.safeParse(statusFn);
+    if (!parsedApply.success || !parsedStatus.success) {
+        throw new CapabilityError('The credentialed worker adapter client must expose apply and status operations.', 'NOT_FOUND', {
+            reason: 'doks-worker-client-incomplete'
+        });
+    }
+    Object.defineProperty(admittedScoped, 'apply', {
+        value: parsedApply.data,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    Object.defineProperty(admittedScoped, 'status', {
+        value: parsedStatus.data,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    return admittedScoped;
+}
+export async function waitForDoksWorker(client, plan, options) {
+    const admittedPlan = admitWorkerPlan(plan);
+    const receiver = resolveReceiver(client);
+    let statusFn;
+    try {
+        statusFn = Object.hasOwn(client, 'status') ? client.status : receiver.status;
+    }
+    catch (cause) {
+        if (cause instanceof CapabilityError)
+            throw cause;
+        throw new CapabilityError('DOKS worker status operation check threw an unexpected error.', 'INVALID_INPUT', {
+            cause: valueFreeFailure(CaughtFailureSchema.parse(cause))
+        });
+    }
+    const parsedStatus = FunctionSchema.safeParse(statusFn);
+    if (!parsedStatus.success) {
+        throw new CapabilityError('DOKS worker status operation is unavailable.', 'NOT_FOUND');
+    }
+    const lifecycle = options.runtime.lifecycle;
+    const deadline = lifecycle.now() + options.timeoutMs;
+    const sleep = options.sleep ?? ((ms) => lifecycle.delay(ms));
+    while (lifecycle.now() <= deadline) {
+        const remainingMs = deadline - lifecycle.now();
+        if (remainingMs <= 0)
+            break;
+        let rawStatus;
+        try {
+            rawStatus = await lifecycle.wait(async () => parsedStatus.data.call(receiver, admittedPlan), {
+                timeoutMs: remainingMs,
+                reason: 'doks-worker-status'
+            });
+        }
+        catch (error) {
+            if (error instanceof CapabilityError) {
+                if (error.reason === 'wait-timeout') {
+                    throw new CapabilityError(`DOKS worker status request timed out after ${options.timeoutMs}ms.`, 'TIMEOUT', { cause: error });
+                }
+                throw error;
+            }
+            throw new CapabilityError('DOKS worker status operation failed.', 'INTERNAL', {
+                cause: valueFreeFailure(CaughtFailureSchema.parse(error))
+            });
+        }
+        const status = admitWorkerStatus(rawStatus);
+        options.onStatus?.(status);
+        if (status.state === 'succeeded')
+            return status;
+        if (status.state === 'failed') {
+            throw new CapabilityError(`DOKS worker ${status.operation} failed: ${status.reason}`, 'INTERNAL');
+        }
+        await sleep(Math.min(options.pollIntervalMs ?? 5_000, Math.max(0, deadline - lifecycle.now())));
+    }
+    throw new CapabilityError(`DOKS worker operation timed out after ${options.timeoutMs}ms.`, 'TIMEOUT');
+}
+export async function applyAndWaitForDoksWorker(client, plan, options) {
+    const admittedPlan = admitWorkerPlan(plan);
+    const receiver = resolveReceiver(client);
+    let applyFn;
+    try {
+        applyFn = Object.hasOwn(client, 'apply') ? client.apply : receiver.apply;
+    }
+    catch (cause) {
+        if (cause instanceof CapabilityError)
+            throw cause;
+        throw new CapabilityError('DOKS worker apply operation check threw an unexpected error.', 'INVALID_INPUT', {
+            cause: valueFreeFailure(CaughtFailureSchema.parse(cause))
+        });
+    }
+    const parsedApply = FunctionSchema.safeParse(applyFn);
+    if (!parsedApply.success) {
+        throw new CapabilityError('DOKS worker apply operation is unavailable.', 'NOT_FOUND');
+    }
+    let rawAppliedPlan;
+    try {
+        rawAppliedPlan = await parsedApply.data.call(receiver, admittedPlan);
+    }
+    catch (error) {
+        if (error instanceof CapabilityError)
+            throw error;
+        throw new CapabilityError('DOKS worker apply operation failed.', 'INTERNAL', {
+            cause: valueFreeFailure(CaughtFailureSchema.parse(error))
+        });
+    }
+    const appliedPlan = admitWorkerPlan(rawAppliedPlan);
+    return waitForDoksWorker(client, appliedPlan, options);
+}
+export async function printWorkerPlan(runtime, plan) {
+    const admittedPlan = admitWorkerPlan(plan);
+    const stdio = await getRuntimeStdio(runtime);
+    stdio.write('stdout', `${JSON.stringify(admittedPlan, null, 2)}\n`);
+}
+//# sourceMappingURL=doks-worker-runtime.js.map