@vibesdotdev/workers 0.0.0-stage → 1.0.0-rc.3

package/dist/code-execution/runner-adapter/interfaces/adapter.kind-augment.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Module augmentation for the `runner/adapter` kind.
+ *
+ * Without this, a bare `runtime.query('runner/adapter')` falls through the
+ * VibesKindTypeMap conditional to `impl: unknown`, so every consumer has to
+ * hand-annotate the impl type — and the client's own annotated assignment
+ * stops typechecking.
+ *
+ * Lives in `interfaces/` so the descriptor module does not need to import from
+ * `./adapter` (which itself imports the descriptor type, forming a cycle). This
+ * file is loaded as a side-effect from `./index`.
+ */
+import type { RunnerAdapterInterface } from './adapter.ts';
+import type { RunnerAdapterDescriptor } from '../kinds/runner-adapter.kind.ts';
+declare global {
+    interface VibesKindTypeMap {
+        'runner/adapter': {
+            descriptor: RunnerAdapterDescriptor;
+            impl: RunnerAdapterInterface;
+        };
+    }
+}
+//# sourceMappingURL=adapter.kind-augment.d.ts.map

package/dist/code-execution/runner-adapter/interfaces/adapter.kind-augment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.kind-augment.d.ts","sourceRoot":"","sources":["../../../../src/code-execution/runner-adapter/interfaces/adapter.kind-augment.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AAC3D,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,iCAAiC,CAAC;AAE/E,OAAO,CAAC,MAAM,CAAC;IACd,UAAU,gBAAgB;QACzB,gBAAgB,EAAE;YAAE,UAAU,EAAE,uBAAuB,CAAC;YAAC,IAAI,EAAE,sBAAsB,CAAA;SAAE,CAAC;KACxF;CACD"}

package/dist/code-execution/runner-adapter/interfaces/adapter.kind-augment.js

@@ -0,0 +1,14 @@
+/**
+ * Module augmentation for the `runner/adapter` kind.
+ *
+ * Without this, a bare `runtime.query('runner/adapter')` falls through the
+ * VibesKindTypeMap conditional to `impl: unknown`, so every consumer has to
+ * hand-annotate the impl type — and the client's own annotated assignment
+ * stops typechecking.
+ *
+ * Lives in `interfaces/` so the descriptor module does not need to import from
+ * `./adapter` (which itself imports the descriptor type, forming a cycle). This
+ * file is loaded as a side-effect from `./index`.
+ */
+export {};
+//# sourceMappingURL=adapter.kind-augment.js.map

package/dist/code-execution/runner-adapter/interfaces/adapter.kind-augment.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.kind-augment.js","sourceRoot":"","sources":["../../../../src/code-execution/runner-adapter/interfaces/adapter.kind-augment.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG"}

package/dist/code-execution/runner-adapter/interfaces/index.d.ts

@@ -0,0 +1,3 @@
+import './adapter.kind-augment.ts';
+export type { RunnerAdapterInterface, RunnerGpuConstraints, RunnerHardwareConstraints, RunnerDeployRequest, RunnerDeployResult, RunnerExecuteRequest, RunnerExecuteResult, RunnerStatusResult, RunnerExecutionStatus, RunnerHealthResult, RunHandle } from './adapter.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/code-execution/runner-adapter/interfaces/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/code-execution/runner-adapter/interfaces/index.ts"],"names":[],"mappings":"AAAA,OAAO,2BAA2B,CAAC;AAEnC,YAAY,EACX,sBAAsB,EACtB,oBAAoB,EACpB,yBAAyB,EACzB,mBAAmB,EACnB,kBAAkB,EAClB,oBAAoB,EACpB,mBAAmB,EACnB,kBAAkB,EAClB,qBAAqB,EACrB,kBAAkB,EAClB,SAAS,EACT,MAAM,cAAc,CAAC"}

package/dist/code-execution/runner-adapter/interfaces/index.js

@@ -0,0 +1,2 @@
+import "./adapter.kind-augment.js";
+//# sourceMappingURL=index.js.map

package/dist/code-execution/runner-adapter/interfaces/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/code-execution/runner-adapter/interfaces/index.ts"],"names":[],"mappings":"AAAA,OAAO,2BAA2B,CAAC"}

package/dist/code-execution/runner-adapter/kinds/index.d.ts

@@ -0,0 +1,5 @@
+export { runnerAdapterKind } from './runner-adapter.kind.ts';
+export type { RunnerAdapterDescriptor } from './runner-adapter.kind.ts';
+export { runnerCapacityKind, RunnerCapacityDescriptorSchema, RunnerCapacityReportSchema, RunnerCapacityIdleDeadlineSchema } from './runner-capacity.kind.ts';
+export type { RunnerCapacityDescriptor, RunnerCapacityReport, RunnerCapacityIdleDeadline, RunnerCapacityImplementation } from './runner-capacity.kind.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/code-execution/runner-adapter/kinds/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/code-execution/runner-adapter/kinds/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAC7D,YAAY,EAAE,uBAAuB,EAAE,MAAM,0BAA0B,CAAC;AACxE,OAAO,EACN,kBAAkB,EAClB,8BAA8B,EAC9B,0BAA0B,EAC1B,gCAAgC,EAChC,MAAM,2BAA2B,CAAC;AACnC,YAAY,EACX,wBAAwB,EACxB,oBAAoB,EACpB,0BAA0B,EAC1B,4BAA4B,EAC5B,MAAM,2BAA2B,CAAC"}

package/dist/code-execution/runner-adapter/kinds/index.js

@@ -0,0 +1,3 @@
+export { runnerAdapterKind } from "./runner-adapter.kind.js";
+export { runnerCapacityKind, RunnerCapacityDescriptorSchema, RunnerCapacityReportSchema, RunnerCapacityIdleDeadlineSchema } from "./runner-capacity.kind.js";
+//# sourceMappingURL=index.js.map

package/dist/code-execution/runner-adapter/kinds/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/code-execution/runner-adapter/kinds/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAE7D,OAAO,EACN,kBAAkB,EAClB,8BAA8B,EAC9B,0BAA0B,EAC1B,gCAAgC,EAChC,MAAM,2BAA2B,CAAC"}

package/dist/code-execution/runner-adapter/kinds/runner-adapter.kind.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Kind: runner/adapter
+ *
+ * Runtime kind for runner adapters — the bridge between machine lifecycle and
+ * run execution. Adapter packages register implementations against this kind;
+ * consumers discover them via `runtime.query('runner/adapter')`.
+ *
+ * Schema shape: strict common base + `config` discriminated union (same pattern
+ * as `infra/sandbox` and `infra/worker` kinds from infra-core).
+ *
+ * - The base defines fields universal across every adapter:
+ *   id/kind/name + backend hint + capabilities + hardware constraints.
+ * - Adapter-specific fields live under `config`. Each adapter package defines
+ *   its own concrete schema under its discriminator key.
+ */
+import * as z from 'zod/v4';
+import type { KindContext } from '@vibesdotdev/kernel/schemas/kind';
+import type { RuntimeDescriptor } from '@vibesdotdev/kernel/schemas/descriptor';
+export declare const RunnerAdapterDescriptorSchema: 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>;
+    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<"runner/adapter">;
+    backend: z.ZodOptional<z.ZodString>;
+    capabilities: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+        local: "local";
+        persistent: "persistent";
+        remote: "remote";
+        gpu: "gpu";
+        "cpu-only": "cpu-only";
+        ephemeral: "ephemeral";
+        preemptible: "preemptible";
+        dedicated: "dedicated";
+        spot: "spot";
+    }>>>;
+    hardwareConstraints: z.ZodOptional<z.ZodObject<{
+        gpu: z.ZodOptional<z.ZodObject<{
+            model: z.ZodOptional<z.ZodString>;
+            vramMb: z.ZodOptional<z.ZodNumber>;
+            count: z.ZodOptional<z.ZodNumber>;
+            driver: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        cpuCores: z.ZodOptional<z.ZodNumber>;
+        ramMb: z.ZodOptional<z.ZodNumber>;
+        diskMb: z.ZodOptional<z.ZodNumber>;
+        os: z.ZodOptional<z.ZodString>;
+        nvidiaToolkit: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    priority: z.ZodDefault<z.ZodNumber>;
+    config: z.ZodOptional<z.ZodObject<{
+        adapter: z.ZodString;
+        image: z.ZodOptional<z.ZodString>;
+        region: z.ZodOptional<z.ZodString>;
+        maxConcurrent: z.ZodOptional<z.ZodNumber>;
+        idleTimeoutMs: z.ZodOptional<z.ZodNumber>;
+        autoProvision: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$loose>>;
+}, z.core.$strip>;
+export type RunnerAdapterDescriptor = z.infer<typeof RunnerAdapterDescriptorSchema>;
+declare class DefaultRunnerAdapterImplementation {
+    readonly descriptor: RuntimeDescriptor;
+    readonly context: KindContext;
+    constructor(descriptor: RuntimeDescriptor, context: KindContext);
+    get config(): RunnerAdapterDescriptor;
+}
+export declare const runnerAdapterKind: import("@vibesdotdev/kernel").RuntimeKindDescriptorRecord<DefaultRunnerAdapterImplementation>;
+export {};
+//# sourceMappingURL=runner-adapter.kind.d.ts.map

package/dist/code-execution/runner-adapter/kinds/runner-adapter.kind.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner-adapter.kind.d.ts","sourceRoot":"","sources":["../../../../src/code-execution/runner-adapter/kinds/runner-adapter.kind.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAE5B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAC;AAEpE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wCAAwC,CAAC;AA+BhF,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAMxC,CAAC;AAEH,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,6BAA6B,CAAC,CAAC;AAEpF,cAAM,kCAAkC;aAEtB,UAAU,EAAE,iBAAiB;aAC7B,OAAO,EAAE,WAAW;gBADpB,UAAU,EAAE,iBAAiB,EAC7B,OAAO,EAAE,WAAW;IAGrC,IAAI,MAAM,IAAI,uBAAuB,CAGpC;CACD;AAED,eAAO,MAAM,iBAAiB,+FAO5B,CAAC"}

package/dist/code-execution/runner-adapter/kinds/runner-adapter.kind.js

@@ -0,0 +1,63 @@
+/**
+ * Kind: runner/adapter
+ *
+ * Runtime kind for runner adapters — the bridge between machine lifecycle and
+ * run execution. Adapter packages register implementations against this kind;
+ * consumers discover them via `runtime.query('runner/adapter')`.
+ *
+ * Schema shape: strict common base + `config` discriminated union (same pattern
+ * as `infra/sandbox` and `infra/worker` kinds from infra-core).
+ *
+ * - The base defines fields universal across every adapter:
+ *   id/kind/name + backend hint + capabilities + hardware constraints.
+ * - Adapter-specific fields live under `config`. Each adapter package defines
+ *   its own concrete schema under its discriminator key.
+ */
+import * as z from 'zod/v4';
+import { createRuntimeKind } from '@vibesdotdev/kernel/factory/kind';
+import { RuntimeDescriptorSchema } from '@vibesdotdev/kernel/schemas/descriptor';
+import { RunnerHardwareConstraintsSchema, RunnerAdapterCapabilitiesSchema, RunnerAdapterConfigSchema } from "../schemas/descriptors.js";
+const RunnerAdapterBaseSchema = RuntimeDescriptorSchema.extend({
+    kind: z.literal('runner/adapter'),
+    /**
+     * Backend hint — which execution backend this adapter targets.
+     * Used by scope resolution to select the right impl for the environment.
+     */
+    backend: z.string().min(1).optional(),
+    /**
+     * Capabilities this adapter reports.
+     */
+    capabilities: RunnerAdapterCapabilitiesSchema.optional(),
+    /**
+     * Default hardware constraints for deployments through this adapter.
+     * Per-request constraints can override these.
+     */
+    hardwareConstraints: RunnerHardwareConstraintsSchema.optional(),
+    /** Priority for scope resolution (higher = preferred). */
+    priority: z.number().int().default(10)
+});
+export const RunnerAdapterDescriptorSchema = RunnerAdapterBaseSchema.extend({
+    /**
+     * Adapter-specific configuration. Discriminated union — each adapter
+     * package defines its own config schema under its discriminator key.
+     */
+    config: RunnerAdapterConfigSchema.optional()
+});
+class DefaultRunnerAdapterImplementation {
+    descriptor;
+    context;
+    constructor(descriptor, context) {
+        this.descriptor = descriptor;
+        this.context = context;
+    }
+    get config() {
+        // SAFETY: Runtime instantiates this default implementation with a verified runner/adapter descriptor
+        return this.descriptor;
+    }
+}
+export const runnerAdapterKind = createRuntimeKind({
+    id: 'runner/adapter',
+    descriptorSchema: RunnerAdapterDescriptorSchema,
+    defaultImplementation: DefaultRunnerAdapterImplementation
+});
+//# sourceMappingURL=runner-adapter.kind.js.map

package/dist/code-execution/runner-adapter/kinds/runner-adapter.kind.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner-adapter.kind.js","sourceRoot":"","sources":["../../../../src/code-execution/runner-adapter/kinds/runner-adapter.kind.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAC5B,OAAO,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AAErE,OAAO,EAAE,uBAAuB,EAAE,MAAM,wCAAwC,CAAC;AAEjF,OAAO,EACN,+BAA+B,EAC/B,+BAA+B,EAC/B,yBAAyB,EACzB,MAAM,2BAA2B,CAAC;AAEnC,MAAM,uBAAuB,GAAG,uBAAuB,CAAC,MAAM,CAAC;IAC9D,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,gBAAgB,CAAC;IAEjC;;;OAGG;IACH,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,EAAE;IAErC;;OAEG;IACH,YAAY,EAAE,+BAA+B,CAAC,QAAQ,EAAE;IAExD;;;OAGG;IACH,mBAAmB,EAAE,+BAA+B,CAAC,QAAQ,EAAE;IAE/D,0DAA0D;IAC1D,QAAQ,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,OAAO,CAAC,EAAE,CAAC;CACtC,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,6BAA6B,GAAG,uBAAuB,CAAC,MAAM,CAAC;IAC3E;;;OAGG;IACH,MAAM,EAAE,yBAAyB,CAAC,QAAQ,EAAE;CAC5C,CAAC,CAAC;AAIH,MAAM,kCAAkC;IAEtB;IACA;IAFjB,YACiB,UAA6B,EAC7B,OAAoB;QADpB,eAAU,GAAV,UAAU,CAAmB;QAC7B,YAAO,GAAP,OAAO,CAAa;IAClC,CAAC;IAEJ,IAAI,MAAM;QACT,qGAAqG;QACrG,OAAO,IAAI,CAAC,UAAqC,CAAC;IACnD,CAAC;CACD;AAED,MAAM,CAAC,MAAM,iBAAiB,GAAG,iBAAiB,CAGhD;IACD,EAAE,EAAE,gBAAgB;IACpB,gBAAgB,EAAE,6BAA6B;IAC/C,qBAAqB,EAAE,kCAAkC;CACzD,CAAC,CAAC"}

package/dist/code-execution/runner-adapter/kinds/runner-capacity.kind.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Kind: runner/capacity
+ *
+ * Generic, provider-neutral capacity report for a runner adapter or runner
+ * pool. Lets consumers (autoloop, scheduler, admin UI, ops dashboards) ask
+ * "how much GPU/CPU capacity do we currently have, how much could we get, and
+ * what is it costing us right now?" without depending on a specific provider.
+ *
+ * Implementations are typically returned in-memory by a runner adapter when
+ * `runtime.query('runner/capacity').withId(adapterId)` is invoked — the
+ * adapter reports based on its current deployment registry plus its
+ * configured guardrails.
+ *
+ * The fields here are intentionally a thin scalar contract — counts,
+ * estimates, and timestamps — to keep aggregation across providers cheap.
+ */
+import * as z from 'zod/v4';
+import type { KindContext } from '@vibesdotdev/kernel/schemas/kind';
+import type { RuntimeDescriptor } from '@vibesdotdev/kernel/schemas/descriptor';
+export declare const RunnerCapacityIdleDeadlineSchema: z.ZodObject<{
+    deploymentId: z.ZodString;
+    teardownAt: z.ZodUnion<readonly [z.ZodDate, z.ZodNull]>;
+}, z.core.$strip>;
+export type RunnerCapacityIdleDeadline = z.infer<typeof RunnerCapacityIdleDeadlineSchema>;
+export declare const RunnerCapacityReportSchema: z.ZodObject<{
+    adapterId: z.ZodString;
+    activeRunners: z.ZodNumber;
+    availableCapacity: z.ZodNumber;
+    maxConcurrent: z.ZodNumber;
+    estimatedHourlyUsd: z.ZodNumber;
+    maxHourlyUsd: z.ZodUnion<readonly [z.ZodNumber, z.ZodNull]>;
+    idleDeadlines: z.ZodArray<z.ZodObject<{
+        deploymentId: z.ZodString;
+        teardownAt: z.ZodUnion<readonly [z.ZodDate, z.ZodNull]>;
+    }, z.core.$strip>>;
+    reportedAt: z.ZodDate;
+}, z.core.$strip>;
+export type RunnerCapacityReport = z.infer<typeof RunnerCapacityReportSchema>;
+export declare const RunnerCapacityDescriptorSchema: 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>>;
+    config: z.ZodOptional<z.ZodUnknown>;
+    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<"runner/capacity">;
+}, z.core.$strip>;
+export type RunnerCapacityDescriptor = z.infer<typeof RunnerCapacityDescriptorSchema>;
+/**
+ * Implementation contract for runner/capacity. A single method, async, that
+ * returns the current report. Implementations should be cheap — no
+ * cross-network calls on the happy path; counts and estimates from local
+ * adapter state only.
+ */
+export interface RunnerCapacityImplementation {
+    readonly descriptor: RuntimeDescriptor;
+    report(): Promise<RunnerCapacityReport>;
+}
+declare class DefaultRunnerCapacityImplementation implements RunnerCapacityImplementation {
+    readonly descriptor: RuntimeDescriptor;
+    readonly context: KindContext;
+    constructor(descriptor: RuntimeDescriptor, context: KindContext);
+    report(): Promise<RunnerCapacityReport>;
+}
+export declare const runnerCapacityKind: import("@vibesdotdev/kernel").RuntimeKindDescriptorRecord<DefaultRunnerCapacityImplementation>;
+export {};
+//# sourceMappingURL=runner-capacity.kind.d.ts.map

package/dist/code-execution/runner-adapter/kinds/runner-capacity.kind.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner-capacity.kind.d.ts","sourceRoot":"","sources":["../../../../src/code-execution/runner-adapter/kinds/runner-capacity.kind.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAE5B,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAC;AAEpE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,wCAAwC,CAAC;AAEhF,eAAO,MAAM,gCAAgC;;;iBAM3C,CAAC;AACH,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAC;AAE1F,eAAO,MAAM,0BAA0B;;;;;;;;;;;;iBAmBrC,CAAC;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAM9E,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;;;;;;;;iBAAqC,CAAC;AAEjF,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,8BAA8B,CAAC,CAAC;AAEtF;;;;;GAKG;AACH,MAAM,WAAW,4BAA4B;IAC5C,QAAQ,CAAC,UAAU,EAAE,iBAAiB,CAAC;IACvC,MAAM,IAAI,OAAO,CAAC,oBAAoB,CAAC,CAAC;CACxC;AAED,cAAM,mCAAoC,YAAW,4BAA4B;aAE/D,UAAU,EAAE,iBAAiB;aAC7B,OAAO,EAAE,WAAW;gBADpB,UAAU,EAAE,iBAAiB,EAC7B,OAAO,EAAE,WAAW;IAG/B,MAAM,IAAI,OAAO,CAAC,oBAAoB,CAAC;CAY7C;AAED,eAAO,MAAM,kBAAkB,gGAO7B,CAAC"}

package/dist/code-execution/runner-adapter/kinds/runner-capacity.kind.js

@@ -0,0 +1,76 @@
+/**
+ * Kind: runner/capacity
+ *
+ * Generic, provider-neutral capacity report for a runner adapter or runner
+ * pool. Lets consumers (autoloop, scheduler, admin UI, ops dashboards) ask
+ * "how much GPU/CPU capacity do we currently have, how much could we get, and
+ * what is it costing us right now?" without depending on a specific provider.
+ *
+ * Implementations are typically returned in-memory by a runner adapter when
+ * `runtime.query('runner/capacity').withId(adapterId)` is invoked — the
+ * adapter reports based on its current deployment registry plus its
+ * configured guardrails.
+ *
+ * The fields here are intentionally a thin scalar contract — counts,
+ * estimates, and timestamps — to keep aggregation across providers cheap.
+ */
+import * as z from 'zod/v4';
+import { createRuntimeKind } from '@vibesdotdev/kernel/factory/kind';
+import { RuntimeDescriptorSchema } from '@vibesdotdev/kernel/schemas/descriptor';
+export const RunnerCapacityIdleDeadlineSchema = z.object({
+    /** Deployment id this deadline applies to. */
+    deploymentId: z.string().min(1),
+    /** When the deployment will be auto-torn-down if no further work arrives.
+     *  `null` means the deployment has no idle teardown configured. */
+    teardownAt: z.union([z.date(), z.null()])
+});
+export const RunnerCapacityReportSchema = z.object({
+    /** Adapter id this report covers (e.g., 'digitalocean-gpu'). */
+    adapterId: z.string().min(1),
+    /** Number of runners currently active (status: ready or running). */
+    activeRunners: z.number().int().nonnegative(),
+    /** Additional runners the adapter could provision without hitting its
+     *  configured cap. May be 0 when at cap. */
+    availableCapacity: z.number().int().nonnegative(),
+    /** Hard cap on concurrent runners for this adapter. */
+    maxConcurrent: z.number().int().nonnegative(),
+    /** Estimated current hourly cost in USD across all active runners. */
+    estimatedHourlyUsd: z.number().nonnegative(),
+    /** Configured ceiling for hourly cost in USD, or `null` if uncapped. */
+    maxHourlyUsd: z.union([z.number().nonnegative(), z.null()]),
+    /** Per-deployment idle teardown deadlines. Empty when adapter has no
+     *  active deployments or no idle timeout configured. */
+    idleDeadlines: z.array(RunnerCapacityIdleDeadlineSchema),
+    /** Timestamp this report was generated. */
+    reportedAt: z.date()
+});
+const RunnerCapacityDescriptorBaseSchema = RuntimeDescriptorSchema.extend({
+    kind: z.literal('runner/capacity')
+});
+export const RunnerCapacityDescriptorSchema = RunnerCapacityDescriptorBaseSchema;
+class DefaultRunnerCapacityImplementation {
+    descriptor;
+    context;
+    constructor(descriptor, context) {
+        this.descriptor = descriptor;
+        this.context = context;
+    }
+    async report() {
+        return {
+            adapterId: this.descriptor.id,
+            activeRunners: 0,
+            availableCapacity: 0,
+            maxConcurrent: 0,
+            estimatedHourlyUsd: 0,
+            maxHourlyUsd: null,
+            idleDeadlines: [],
+            reportedAt: new Date()
+        };
+    }
+}
+export const runnerCapacityKind = createRuntimeKind({
+    id: 'runner/capacity',
+    descriptorSchema: RunnerCapacityDescriptorSchema,
+    defaultImplementation: DefaultRunnerCapacityImplementation
+});
+//# sourceMappingURL=runner-capacity.kind.js.map

package/dist/code-execution/runner-adapter/kinds/runner-capacity.kind.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner-capacity.kind.js","sourceRoot":"","sources":["../../../../src/code-execution/runner-adapter/kinds/runner-capacity.kind.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAC5B,OAAO,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AAErE,OAAO,EAAE,uBAAuB,EAAE,MAAM,wCAAwC,CAAC;AAGjF,MAAM,CAAC,MAAM,gCAAgC,GAAG,CAAC,CAAC,MAAM,CAAC;IACxD,8CAA8C;IAC9C,YAAY,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC/B;uEACmE;IACnE,UAAU,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;CACzC,CAAC,CAAC;AAGH,MAAM,CAAC,MAAM,0BAA0B,GAAG,CAAC,CAAC,MAAM,CAAC;IAClD,gEAAgE;IAChE,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC5B,qEAAqE;IACrE,aAAa,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE;IAC7C;gDAC4C;IAC5C,iBAAiB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE;IACjD,uDAAuD;IACvD,aAAa,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,EAAE,CAAC,WAAW,EAAE;IAC7C,sEAAsE;IACtE,kBAAkB,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,WAAW,EAAE;IAC5C,wEAAwE;IACxE,YAAY,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,WAAW,EAAE,EAAE,CAAC,CAAC,IAAI,EAAE,CAAC,CAAC;IAC3D;4DACwD;IACxD,aAAa,EAAE,CAAC,CAAC,KAAK,CAAC,gCAAgC,CAAC;IACxD,2CAA2C;IAC3C,UAAU,EAAE,CAAC,CAAC,IAAI,EAAE;CACpB,CAAC,CAAC;AAGH,MAAM,kCAAkC,GAAG,uBAAuB,CAAC,MAAM,CAAC;IACzE,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,iBAAiB,CAAC;CAClC,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,8BAA8B,GAAG,kCAAkC,CAAC;AAejF,MAAM,mCAAmC;IAEvB;IACA;IAFjB,YACiB,UAA6B,EAC7B,OAAoB;QADpB,eAAU,GAAV,UAAU,CAAmB;QAC7B,YAAO,GAAP,OAAO,CAAa;IAClC,CAAC;IAEJ,KAAK,CAAC,MAAM;QACX,OAAO;YACN,SAAS,EAAE,IAAI,CAAC,UAAU,CAAC,EAAE;YAC7B,aAAa,EAAE,CAAC;YAChB,iBAAiB,EAAE,CAAC;YACpB,aAAa,EAAE,CAAC;YAChB,kBAAkB,EAAE,CAAC;YACrB,YAAY,EAAE,IAAI;YAClB,aAAa,EAAE,EAAE;YACjB,UAAU,EAAE,IAAI,IAAI,EAAE;SACtB,CAAC;IACH,CAAC;CACD;AAED,MAAM,CAAC,MAAM,kBAAkB,GAAG,iBAAiB,CAGjD;IACD,EAAE,EAAE,iBAAiB;IACrB,gBAAgB,EAAE,8BAA8B;IAChD,qBAAqB,EAAE,mCAAmC;CAC1D,CAAC,CAAC"}

package/dist/code-execution/runner-adapter/runner-adapter.plugin.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Runner Adapter Runtime Plugin
+ *
+ * Registers the `runner/adapter` kind with the runtime. Adapter packages
+ * (runner-adapter-docker, runner-adapter-bun, runner-adapter-digitalocean, …)
+ * register their descriptor+impl pairs against this kind; consumers discover
+ * them via `runtime.query('runner/adapter')`.
+ */
+declare const runnerAdapterPlugin: import("@vibesdotdev/kernel").RuntimePlugin;
+export default runnerAdapterPlugin;
+//# sourceMappingURL=runner-adapter.plugin.d.ts.map

package/dist/code-execution/runner-adapter/runner-adapter.plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner-adapter.plugin.d.ts","sourceRoot":"","sources":["../../../src/code-execution/runner-adapter/runner-adapter.plugin.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAMH,QAAA,MAAM,mBAAmB,6CAiBvB,CAAC;AAEH,eAAe,mBAAmB,CAAC"}

package/dist/code-execution/runner-adapter/runner-adapter.plugin.js

@@ -0,0 +1,30 @@
+/**
+ * Runner Adapter Runtime Plugin
+ *
+ * Registers the `runner/adapter` kind with the runtime. Adapter packages
+ * (runner-adapter-docker, runner-adapter-bun, runner-adapter-digitalocean, …)
+ * register their descriptor+impl pairs against this kind; consumers discover
+ * them via `runtime.query('runner/adapter')`.
+ */
+import { createRuntimePlugin, loader } from '@vibesdotdev/kernel';
+import { runnerAdapterKind } from "./kinds/runner-adapter.kind.js";
+import { runnerCapacityKind } from "./kinds/runner-capacity.kind.js";
+const runnerAdapterPlugin = createRuntimePlugin({
+    id: 'runner-adapter',
+    name: 'Runner Adapters',
+    description: 'Bridge between machine lifecycle (platform/hosts + infra/sandbox) and run execution (runnable/runnable). Adapter packages implement provider-specific deploy/execute/teardown behavior.',
+    dependencies: ['runtime-client'],
+    kinds: [runnerAdapterKind, runnerCapacityKind],
+    descriptors: [
+        {
+            id: 'runner-adapter',
+            kind: 'runtime/client',
+            description: 'Canonical runner-adapter discovery, deploy and execute client.'
+        }
+    ],
+    loaders: [
+        loader('runner-adapter', { kind: 'runtime/client' }, () => import("./client/index.js"))
+    ]
+});
+export default runnerAdapterPlugin;
+//# sourceMappingURL=runner-adapter.plugin.js.map

package/dist/code-execution/runner-adapter/runner-adapter.plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner-adapter.plugin.js","sourceRoot":"","sources":["../../../src/code-execution/runner-adapter/runner-adapter.plugin.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,mBAAmB,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAClE,OAAO,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AACnE,OAAO,EAAE,kBAAkB,EAAE,MAAM,iCAAiC,CAAC;AAErE,MAAM,mBAAmB,GAAG,mBAAmB,CAAC;IAC/C,EAAE,EAAE,gBAAgB;IACpB,IAAI,EAAE,iBAAiB;IACvB,WAAW,EACV,yLAAyL;IAC1L,YAAY,EAAE,CAAC,gBAAgB,CAAC;IAChC,KAAK,EAAE,CAAC,iBAAiB,EAAE,kBAAkB,CAAC;IAC9C,WAAW,EAAE;QACZ;YACC,EAAE,EAAE,gBAAgB;YACpB,IAAI,EAAE,gBAAgB;YACtB,WAAW,EAAE,gEAAgE;SAC7E;KACD;IACD,OAAO,EAAE;QACR,MAAM,CAAC,gBAAgB,EAAE,EAAE,IAAI,EAAE,gBAAgB,EAAE,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,mBAAmB,CAAC,CAAC;KACvF;CACD,CAAC,CAAC;AAEH,eAAe,mBAAmB,CAAC"}

package/dist/code-execution/runner-adapter/schemas/descriptors.d.ts

@@ -0,0 +1,105 @@
+/**
+ * Runner Adapter Schemas
+ *
+ * Shared Zod schemas for the runner/adapter kind. Kind descriptor schemas
+ * compose from these primitives. Adapter packages import these for their
+ * own config schema extensions.
+ */
+import * as z from 'zod/v4';
+export declare const RunnerGpuConstraintsSchema: z.ZodObject<{
+    model: z.ZodOptional<z.ZodString>;
+    vramMb: z.ZodOptional<z.ZodNumber>;
+    count: z.ZodOptional<z.ZodNumber>;
+    driver: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type RunnerGpuConstraints = z.infer<typeof RunnerGpuConstraintsSchema>;
+export declare const RunnerHardwareConstraintsSchema: z.ZodObject<{
+    gpu: z.ZodOptional<z.ZodObject<{
+        model: z.ZodOptional<z.ZodString>;
+        vramMb: z.ZodOptional<z.ZodNumber>;
+        count: z.ZodOptional<z.ZodNumber>;
+        driver: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    cpuCores: z.ZodOptional<z.ZodNumber>;
+    ramMb: z.ZodOptional<z.ZodNumber>;
+    diskMb: z.ZodOptional<z.ZodNumber>;
+    os: z.ZodOptional<z.ZodString>;
+    nvidiaToolkit: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+export type RunnerHardwareConstraints = z.infer<typeof RunnerHardwareConstraintsSchema>;
+export declare const RunnerAdapterCapabilitiesSchema: z.ZodArray<z.ZodEnum<{
+    local: "local";
+    persistent: "persistent";
+    remote: "remote";
+    gpu: "gpu";
+    "cpu-only": "cpu-only";
+    ephemeral: "ephemeral";
+    preemptible: "preemptible";
+    dedicated: "dedicated";
+    spot: "spot";
+}>>;
+export declare const RunnerAdapterBaseConfigSchema: z.ZodObject<{
+    image: z.ZodOptional<z.ZodString>;
+    region: z.ZodOptional<z.ZodString>;
+    maxConcurrent: z.ZodOptional<z.ZodNumber>;
+    idleTimeoutMs: z.ZodOptional<z.ZodNumber>;
+    autoProvision: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+/**
+ * Config schema for the kind definition.
+ *
+ * Base shape with a generic discriminator. Adapter packages replace this
+ * with their own narrowed config schema when registering descriptors
+ * (via schema extension, same pattern as infra/sandbox).
+ */
+export declare const RunnerAdapterConfigSchema: z.ZodObject<{
+    adapter: z.ZodString;
+    image: z.ZodOptional<z.ZodString>;
+    region: z.ZodOptional<z.ZodString>;
+    maxConcurrent: z.ZodOptional<z.ZodNumber>;
+    idleTimeoutMs: z.ZodOptional<z.ZodNumber>;
+    autoProvision: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$loose>;
+export declare const RunnerDeployRequestSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+    hardware: z.ZodOptional<z.ZodObject<{
+        gpu: z.ZodOptional<z.ZodObject<{
+            model: z.ZodOptional<z.ZodString>;
+            vramMb: z.ZodOptional<z.ZodNumber>;
+            count: z.ZodOptional<z.ZodNumber>;
+            driver: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+        cpuCores: z.ZodOptional<z.ZodNumber>;
+        ramMb: z.ZodOptional<z.ZodNumber>;
+        diskMb: z.ZodOptional<z.ZodNumber>;
+        os: z.ZodOptional<z.ZodString>;
+        nvidiaToolkit: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>>;
+    provider: z.ZodOptional<z.ZodString>;
+    region: z.ZodOptional<z.ZodString>;
+    image: z.ZodOptional<z.ZodString>;
+    env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    config: z.ZodOptional<z.ZodType<import("@vibesdotdev/kernel/schemas/json").JsonObject, import("@vibesdotdev/kernel/schemas/json").JsonObject, z.core.$ZodTypeInternals<import("@vibesdotdev/kernel/schemas/json").JsonObject, import("@vibesdotdev/kernel/schemas/json").JsonObject>>>;
+    workspacePath: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export type RunnerDeployRequest = z.infer<typeof RunnerDeployRequestSchema>;
+export declare const RunnerExecuteRequestSchema: z.ZodObject<{
+    deploymentId: z.ZodString;
+    runnableType: z.ZodString;
+    config: z.ZodType<import("@vibesdotdev/kernel/schemas/json").JsonObject, import("@vibesdotdev/kernel/schemas/json").JsonObject, z.core.$ZodTypeInternals<import("@vibesdotdev/kernel/schemas/json").JsonObject, import("@vibesdotdev/kernel/schemas/json").JsonObject>>;
+    timeoutMs: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export type RunnerExecuteRequest = z.infer<typeof RunnerExecuteRequestSchema>;
+export declare const RunnerExecuteResultSchema: z.ZodObject<{
+    executionId: z.ZodString;
+    result: z.ZodType<import("@vibesdotdev/kernel/bootstrap").JsonValue, import("@vibesdotdev/kernel/bootstrap").JsonValue, z.core.$ZodTypeInternals<import("@vibesdotdev/kernel/bootstrap").JsonValue, import("@vibesdotdev/kernel/bootstrap").JsonValue>>;
+    durationMs: z.ZodNumber;
+    utilization: z.ZodOptional<z.ZodObject<{
+        gpuPercent: z.ZodOptional<z.ZodNumber>;
+        ramPercent: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type RunnerExecuteResult = z.infer<typeof RunnerExecuteResultSchema>;
+//# sourceMappingURL=descriptors.d.ts.map

package/dist/code-execution/runner-adapter/schemas/descriptors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"descriptors.d.ts","sourceRoot":"","sources":["../../../../src/code-execution/runner-adapter/schemas/descriptors.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAK5B,eAAO,MAAM,0BAA0B;;;;;iBAKrC,CAAC;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAI9E,eAAO,MAAM,+BAA+B;;;;;;;;;;;;iBAO1C,CAAC;AACH,MAAM,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,+BAA+B,CAAC,CAAC;AAIxF,eAAO,MAAM,+BAA+B;;;;;;;;;;GAY3C,CAAC;AAUF,eAAO,MAAM,6BAA6B;;;;;;iBAWxC,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB;;;;;;;iBAGpC,CAAC;AAOH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;iBAWpC,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E,eAAO,MAAM,0BAA0B;;;;;iBAKrC,CAAC;AACH,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAE9E,eAAO,MAAM,yBAAyB;;;;;;;;iBAQpC,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC"}