@nylorun/runtime 0.22.0-beta → 0.23.0-beta

package/dist/host/stack-config.d.ts

@@ -39,6 +39,12 @@ export interface StackEndpoints {
     restateIngressUrl?: string;
     restateAdminUrl?: string;
     workerUrl?: string;
+    /**
+     * The Worker deployment's version, from `NYLORUN_WORKER_VERSION` (default: the Runtime's
+     * version): the Worker registers `<NYLORUN_WORKER_URL>/nylorun/<version>` with Restate
+     * (`infra/execution.ts`, `workerDeployment`).
+     */
+    workerVersion?: string;
     s2Endpoint?: string;
     s2Token?: string;
     workspaceStoreUrl?: string;

package/dist/host/stack-config.js

@@ -281,6 +281,12 @@ export function parseStackConfig(env, argv) {
     const workerUrl = parseUrl(env, "NYLORUN_WORKER_URL", http);
     if (workerUrl)
         endpoints.workerUrl = workerUrl;
+    const workerVersion = read(env, "NYLORUN_WORKER_VERSION");
+    if (workerVersion !== undefined) {
+        if (!/^[A-Za-z0-9._-]{1,64}$/.test(workerVersion))
+            throw new StackConfigError("NYLORUN_WORKER_VERSION must be 1 to 64 letters, digits, `.`, `_` or `-` (it is a URL path segment)");
+        endpoints.workerVersion = workerVersion;
+    }
     const s2Endpoint = parseUrl(env, "NYLORUN_S2_ENDPOINT", http);
     if (s2Endpoint)
         endpoints.s2Endpoint = s2Endpoint;

package/dist/infra/execution.d.ts

@@ -29,7 +29,24 @@ export declare function executionKind(config: Pick<StackConfig, "endpoints">): "
 export declare function validateExecutionConfig(config: Pick<StackConfig, "endpoints"> & {
     services?: RuntimeServices;
 }): void;
-export declare function createExecution(config: Pick<StackConfig, "endpoints"> & {
+/**
+ * The deployment a Worker registers with Restate (§14.6): `<NYLORUN_WORKER_URL>/nylorun/<version>`,
+ * the version being `NYLORUN_WORKER_VERSION` or the Runtime's. Restate sends new invocations to
+ * the latest deployment of a service and keeps each running invocation on the deployment it
+ * started on, so during a rolling upgrade the Workers of one version share that version's
+ * deployment (behind one load-balanced `NYLORUN_WORKER_URL`) and the old one finishes what it
+ * started; the endpoint answers on any path, so an older deployment's URL still reaches it.
+ * `force` replaces a deployment already registered at the URL with different code: only
+ * outside a container (a development Host, whose code changes under one version). Without
+ * it Restate keeps the deployment it already has at the URL, and a Worker whose services that
+ * deployment lacks refuses to start: a build whose code changed under the same version sets
+ * its own `NYLORUN_WORKER_VERSION`.
+ */
+export declare function workerDeployment(config: Pick<StackConfig, "endpoints" | "listen">): {
+    url: string;
+    force: boolean;
+} | undefined;
+export declare function createExecution(config: Pick<StackConfig, "endpoints" | "listen"> & {
     services?: RuntimeServices;
 }, options?: CreateExecutionOptions): DurableExecution;
 /**

package/dist/infra/execution.js

@@ -8,8 +8,8 @@
  * - wakes, timers and sweep arming go through the ingress, so every process can
  *   call them;
  * - a Worker (a process running the loop service) serves the Restate endpoint on
- *   `0.0.0.0:9080` and registers `NYLORUN_WORKER_URL` with the admin API when
- *   `infra/workers.ts` starts it;
+ *   `0.0.0.0:9080` and registers it with the admin API when `infra/workers.ts` starts it,
+ *   as a versioned deployment (`workerDeployment`);
  * - with `NYLORUN_RESTATE_IDENTITY_KEY` the endpoint accepts only requests
  *   signed by the Restate server holding the matching private key.
  *
@@ -17,6 +17,7 @@
  * only unit tests and a local development Host use.
  */
 import { createRestateExecution } from "../adapters/execution/restate.js";
+import { RUNTIME_VERSION } from "../version.js";
 import { MemoryExecution } from "../execution/memory.js";
 import { DEFAULT_SERVICES, describeServices, } from "../host/stack-config.js";
 /** Where a Worker serves the Restate endpoint (architecture §14.3). */
@@ -46,16 +47,39 @@ export function validateExecutionConfig(config) {
     if (services.has("loop") && !workerUrl)
         throw new Error(`NYLORUN_WORKER_URL is required for --service ${describeServices(services)}: the Worker endpoint URL Restate calls`);
 }
+/**
+ * The deployment a Worker registers with Restate (§14.6): `<NYLORUN_WORKER_URL>/nylorun/<version>`,
+ * the version being `NYLORUN_WORKER_VERSION` or the Runtime's. Restate sends new invocations to
+ * the latest deployment of a service and keeps each running invocation on the deployment it
+ * started on, so during a rolling upgrade the Workers of one version share that version's
+ * deployment (behind one load-balanced `NYLORUN_WORKER_URL`) and the old one finishes what it
+ * started; the endpoint answers on any path, so an older deployment's URL still reaches it.
+ * `force` replaces a deployment already registered at the URL with different code: only
+ * outside a container (a development Host, whose code changes under one version). Without
+ * it Restate keeps the deployment it already has at the URL, and a Worker whose services that
+ * deployment lacks refuses to start: a build whose code changed under the same version sets
+ * its own `NYLORUN_WORKER_VERSION`.
+ */
+export function workerDeployment(config) {
+    const { workerUrl, workerVersion } = config.endpoints;
+    if (!workerUrl)
+        return undefined;
+    const version = encodeURIComponent(workerVersion ?? RUNTIME_VERSION);
+    return { url: `${workerUrl.replace(/\/+$/, "")}/nylorun/${version}`, force: !config.listen };
+}
 export function createExecution(config, options = {}) {
     validateExecutionConfig(config);
-    const { restateIngressUrl, restateAdminUrl, workerUrl, restateIdentityKeys } = config.endpoints;
+    const { restateIngressUrl, restateAdminUrl, restateIdentityKeys } = config.endpoints;
     if (!restateIngressUrl || !restateAdminUrl)
         return new MemoryExecution();
+    const deployment = workerDeployment(config);
     return createRestateExecution({
         ingressUrl: restateIngressUrl,
         adminUrl: restateAdminUrl,
         workerListen: options.workerListen ?? { ...WORKER_LISTEN },
-        ...(workerUrl ? { workerAdvertisedUrl: workerUrl } : {}),
+        ...(deployment
+            ? { workerAdvertisedUrl: deployment.url, forceRegistration: deployment.force }
+            : {}),
         ...(restateIdentityKeys?.length ? { identityKeys: [...restateIdentityKeys] } : {}),
         ...(options.servicePrefix ? { servicePrefix: options.servicePrefix } : {}),
         ...(options.logger ? { logger: options.logger } : {}),

package/dist/infra/index.d.ts

@@ -36,7 +36,7 @@ export interface Infra {
  * Builds the configured clients. Throws naming the variable when endpoints are
  * incomplete (e.g. a Restate ingress without an admin URL).
  */
-export declare function createInfra(config: Pick<StackConfig, "services" | "endpoints">, options?: {
+export declare function createInfra(config: Pick<StackConfig, "services" | "endpoints" | "listen">, options?: {
     logger?: Logger;
     execution?: CreateExecutionOptions;
     streams?: CreateStreamsOptions;

package/dist/management-openapi.json

@@ -2,7 +2,7 @@
   "openapi": "3.2.0",
   "info": {
     "title": "Nylorun Management API",
-    "version": "0.22.0-beta",
+    "version": "0.23.0-beta",
     "x-nylorun-protocol": {
       "min": 4,
       "max": 10,

package/dist/openapi.json

@@ -2,7 +2,7 @@
   "openapi": "3.2.0",
   "info": {
     "title": "Nylorun Runtime API",
-    "version": "0.22.0-beta",
+    "version": "0.23.0-beta",
     "x-nylorun-protocol": {
       "min": 4,
       "max": 10,

package/dist/retry.d.ts

@@ -0,0 +1,21 @@
+/** Waits `ms`, or until `signal` aborts; resolves either way and never rejects. */
+export declare function sleep(ms: number, signal?: AbortSignal): Promise<void>;
+export interface RetryOptions {
+    /** The first wait after a failure. Doubled after each, up to `maxMs`. */
+    minMs: number;
+    maxMs: number;
+    /** Attempts, the first included, before giving up. Default: no limit. */
+    attempts?: number;
+    /** Gives up when the next wait would end later than this long after the first attempt. */
+    deadlineMs?: number;
+    /** Gives up when it aborts, after the attempt or wait under way. */
+    signal?: AbortSignal;
+    /** Called with each failure that is retried, and how many attempts have failed so far. */
+    onError?: (error: unknown, failures: number) => void;
+}
+/**
+ * Runs `attempt` until it resolves, waiting between failures with exponential backoff
+ * (`minMs`, doubling to `maxMs`). Rejects with the last failure once `attempts`, `deadlineMs`
+ * or `signal` ends the retries.
+ */
+export declare function retry<T>(attempt: () => Promise<T>, options: RetryOptions): Promise<T>;

package/dist/retry.js

@@ -0,0 +1,34 @@
+/**
+ * Waiting and retrying, shared by the Runtime's background loops and its calls to other
+ * services. Nothing here logs or decides what is worth retrying: callers do.
+ */
+import { setTimeout as delay } from "node:timers/promises";
+/** Waits `ms`, or until `signal` aborts; resolves either way and never rejects. */
+export function sleep(ms, signal) {
+    return delay(ms, undefined, signal ? { signal } : undefined).catch(() => undefined);
+}
+/**
+ * Runs `attempt` until it resolves, waiting between failures with exponential backoff
+ * (`minMs`, doubling to `maxMs`). Rejects with the last failure once `attempts`, `deadlineMs`
+ * or `signal` ends the retries.
+ */
+export async function retry(attempt, options) {
+    const deadline = options.deadlineMs === undefined ? Infinity : Date.now() + options.deadlineMs;
+    let wait = options.minMs;
+    for (let failures = 1;; failures += 1) {
+        try {
+            return await attempt();
+        }
+        catch (error) {
+            if (failures >= (options.attempts ?? Infinity) ||
+                Date.now() + wait > deadline ||
+                options.signal?.aborted)
+                throw error;
+            options.onError?.(error, failures);
+            await sleep(wait, options.signal);
+            if (options.signal?.aborted)
+                throw error;
+            wait = Math.min(wait * 2, options.maxMs);
+        }
+    }
+}

package/dist/sandbox/join.js

@@ -134,6 +134,9 @@ export function hostAuthority(ctx) {
                     const reason = "The sandbox's volume was replaced: its files are gone";
                     await t.updateSandboxPod(sandboxId, { observed: "lost", reason, hostEpoch: epoch }, now);
                     await t.sandboxEvent(sandboxId, "sandbox.lost", { reason });
+                    // Its Sandbox is deleted; only a reset brings the sandbox back.
+                    await t.signal({ type: "host.revoked", sandboxId, epoch });
+                    await t.signalSandbox(sandboxId, { kind: "reconcile" });
                     return { lost: epoch };
                 }
                 await t.updateSandboxPod(sandboxId, {
@@ -148,16 +151,12 @@ export function hostAuthority(ctx) {
                     else
                         await t.sandboxEvent(sandboxId, "sandbox.running", { hostEpoch: epoch });
                 }
+                // The previous host's connection (an older epoch) serves nothing more, on any process.
+                await t.signal({ type: "host.revoked", sandboxId, epoch });
                 return epoch;
             });
-            if (typeof joined === "object") {
-                ctx.harness.revokeHost(sandboxId, joined.lost);
-                // Its Sandbox is deleted; only a reset brings the sandbox back.
-                await ctx.sandboxSignal(sandboxId, { kind: "reconcile" });
+            if (typeof joined === "object")
                 return refuse("the volume was replaced: the sandbox is lost");
-            }
-            // The previous host's connection (an older epoch) serves nothing more.
-            ctx.harness.revokeHost(sandboxId, joined);
             ctx.config.logger.info("sandbox host joined", { sandboxId, epoch: joined });
             return answerOf(await mintHostTokens(ctx, { sandboxId, epoch: joined, podUid }), await ctx.keys.egressCa());
         },

package/dist/sandbox/pods/reconcile.js

@@ -135,7 +135,9 @@ export async function reconcileSandbox(ctx, sandboxId, trigger) {
             await t.updateSandboxPod(sandboxId, finalPatch, new Date().toISOString());
         for (const item of decision.events)
             await t.sandboxEvent(sandboxId, item.type, item.payload);
-        return { kind: "written", epoch: epochMoved ? current.pod.hostEpoch + 1 : undefined };
+        if (epochMoved)
+            await t.signal({ type: "host.revoked", sandboxId, epoch: finalPatch.hostEpoch });
+        return { kind: "written" };
     });
     if (written.kind === "changed")
         return { retryAfterMs: 0 };
@@ -143,8 +145,6 @@ export async function reconcileSandbox(ctx, sandboxId, trigger) {
         await ctx.sandbox.removeSandbox(sandboxId).catch(() => undefined);
         return {};
     }
-    if (written.kind === "written" && written.epoch !== undefined)
-        ctx.harness.revokeHost(sandboxId, written.epoch);
     return {
         ...(decision.retryAfterMs === undefined ? {} : { retryAfterMs: decision.retryAfterMs }),
         ...(decision.arm.length > 0 ? { arm: decision.arm } : {}),

package/dist/store/postgres/control.js

@@ -1,7 +1,8 @@
 /**
  * The control bus on Postgres (blueprint D21, D48): how one process tells the others with the
  * Tenant open to act now. `session.cancel` aborts the advance of a cancelled turn;
- * `sessions.reset` moves the session streams to the Tenant's new basin generation. Nothing
+ * `sessions.reset` moves the session streams to the Tenant's new basin generation;
+ * `host.revoked` closes a pod sandbox's host connections of an older epoch. Nothing
  * internal goes through S2, which only serves API listeners.
  *
  * - **Write.** `writeSignal` inserts a `control_signals` row and calls `pg_notify` on
@@ -36,6 +37,8 @@ const SIGNAL = {
     sessionId: controlSignals.sessionId,
     turnId: controlSignals.turnId,
     generation: controlSignals.generation,
+    sandboxId: controlSignals.sandboxId,
+    epoch: controlSignals.epoch,
 };
 /** Puts `signal` on the bus in the transaction `db` runs: a row, notified at commit. */
 export async function writeSignal(db, signal) {
@@ -46,6 +49,8 @@ export async function writeSignal(db, signal) {
         sessionId: signal.type === "session.cancel" ? signal.sessionId : null,
         turnId: signal.type === "session.cancel" ? (signal.turnId ?? null) : null,
         generation: signal.type === "sessions.reset" ? signal.generation : null,
+        sandboxId: signal.type === "host.revoked" ? signal.sandboxId : null,
+        epoch: signal.type === "host.revoked" ? signal.epoch : null,
     })
         .returning({ id: controlSignals.id });
     // The payload is only the id: a follower reads the rows back either way.
@@ -183,5 +188,7 @@ function signalOf(row) {
         };
     if (row.kind === "sessions.reset" && row.generation !== null)
         return { type: "sessions.reset", generation: row.generation };
+    if (row.kind === "host.revoked" && row.sandboxId !== null && row.epoch !== null)
+        return { type: "host.revoked", sandboxId: row.sandboxId, epoch: row.epoch };
     return undefined;
 }

package/dist/store/postgres/drizzle/0018_wake_outbox_retries.sql

@@ -0,0 +1,3 @@
+ALTER TABLE "nylorun"."wakes" ADD COLUMN "attempts" integer DEFAULT 0 NOT NULL;--> statement-breakpoint
+ALTER TABLE "nylorun"."wakes" ADD COLUMN "retry_at" timestamp with time zone;--> statement-breakpoint
+ALTER TABLE "nylorun"."wakes" ADD COLUMN "parked_at" timestamp with time zone;

package/dist/store/postgres/drizzle/0019_sandbox_signal_outbox.sql

@@ -0,0 +1,18 @@
+CREATE TABLE "nylorun"."sandbox_signals" (
+	"id" text COLLATE "C" PRIMARY KEY NOT NULL,
+	"sandbox_id" text COLLATE "C" NOT NULL,
+	"kind" text NOT NULL,
+	"timer" text,
+	"at" bigint,
+	"created_at" timestamp with time zone DEFAULT clock_timestamp() NOT NULL,
+	"attempts" integer DEFAULT 0 NOT NULL,
+	"retry_at" timestamp with time zone,
+	"parked_at" timestamp with time zone,
+	CONSTRAINT "sandbox_signals_kind_check" CHECK ("nylorun"."sandbox_signals"."kind" IN ('reconcile', 'arm'))
+);
+--> statement-breakpoint
+ALTER TABLE "nylorun"."control_signals" DROP CONSTRAINT "control_signals_kind_check";--> statement-breakpoint
+ALTER TABLE "nylorun"."control_signals" ADD COLUMN "sandbox_id" text COLLATE "C";--> statement-breakpoint
+ALTER TABLE "nylorun"."control_signals" ADD COLUMN "epoch" integer;--> statement-breakpoint
+CREATE INDEX "sandbox_signals_created_at" ON "nylorun"."sandbox_signals" USING btree ("created_at");--> statement-breakpoint
+ALTER TABLE "nylorun"."control_signals" ADD CONSTRAINT "control_signals_kind_check" CHECK ("nylorun"."control_signals"."kind" IN ('session.cancel', 'sessions.reset', 'host.revoked'));

package/dist/store/postgres/drizzle/meta/_journal.json

@@ -127,6 +127,20 @@
       "when": 1791455573196,
       "tag": "0017_wake_outbox",
       "breakpoints": true
+    },
+    {
+      "idx": 18,
+      "version": "7",
+      "when": 1791529391438,
+      "tag": "0018_wake_outbox_retries",
+      "breakpoints": true
+    },
+    {
+      "idx": 19,
+      "version": "7",
+      "when": 1791530515498,
+      "tag": "0019_sandbox_signal_outbox",
+      "breakpoints": true
     }
   ]
 }

package/dist/store/postgres/schema.d.ts

@@ -3225,7 +3225,8 @@ export declare const definitionFileUses: import("drizzle-orm/pg-core").PgTableWi
  * written in the transaction that commits what they announce and notified on
  * `nylorun_control` at commit (`control.ts`). A row outlives its notification so a process
  * whose listener was down catches up; the Tenant sweep deletes old ones. `created_at` is the
- * insert's own clock (`clock_timestamp()`), not its transaction's start.
+ * insert's own clock (`clock_timestamp()`), not its transaction's start. `sandbox_id` and
+ * `epoch` are a `host.revoked` signal's.
  */
 export declare const controlSignals: import("drizzle-orm/pg-core").PgTableWithColumns<{
     name: "control_signals";
@@ -3337,6 +3338,42 @@ export declare const controlSignals: import("drizzle-orm/pg-core").PgTableWithCo
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        sandboxId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "sandboxId";
+            tableName: "control_signals";
+            dataType: "custom";
+            columnType: "PgCustomColumn";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            pgColumnBuilderBrand: 'PgCustomColumnBuilderBrand';
+        }>;
+        epoch: import("drizzle-orm/pg-core").PgColumn<{
+            name: "epoch";
+            tableName: "control_signals";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
     };
     dialect: 'pg';
 }>;
@@ -3345,7 +3382,9 @@ export declare const controlSignals: import("drizzle-orm/pg-core").PgTableWithCo
  * (`Tx.wake`), written in that transaction, so a commit never loses its wake. The row is
  * deleted once Durable Session Execution has accepted the wake; until then the Tenant sweep
  * delivers it again, with the same idempotency key (`dedupe_key`, or `wake:<id>` without
- * one). `created_at` is the insert's own clock (`clock_timestamp()`).
+ * one). `created_at` is the insert's own clock (`clock_timestamp()`). `attempts` counts the
+ * sweep's failed deliveries, `retry_at` is when it tries the row again, and a row
+ * `parked_at` is never tried again: it stays for an operator (`Tx.failOutbox`).
  */
 export declare const wakes: import("drizzle-orm/pg-core").PgTableWithColumns<{
     name: "wakes";
@@ -3440,6 +3479,228 @@ export declare const wakes: import("drizzle-orm/pg-core").PgTableWithColumns<{
             identity: undefined;
             generated: undefined;
         }, {}, {}>;
+        attempts: import("drizzle-orm/pg-core").PgColumn<{
+            name: "attempts";
+            tableName: "wakes";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        retryAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "retryAt";
+            tableName: "wakes";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        parkedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "parkedAt";
+            tableName: "wakes";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: 'pg';
+}>;
+/**
+ * The sandbox signal outbox (F7.2): one row per pod sandbox reconcile or timer a committed
+ * transaction asked for (`Tx.signalSandbox`), kept and delivered as the wake outbox's rows are
+ * (`attempts`, `retry_at`, `parked_at`). A reconcile is sent with the idempotency key
+ * `signal:<id>`; a timer (`kind` `arm`) is its `timer` at `at` (ms since the epoch). Not in
+ * `wakes`, so a Runtime that delivers only wakes never reads one.
+ */
+export declare const sandboxSignals: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: "sandbox_signals";
+    schema: "nylorun";
+    columns: {
+        id: import("drizzle-orm/pg-core").PgColumn<{
+            name: "id";
+            tableName: "sandbox_signals";
+            dataType: "custom";
+            columnType: "PgCustomColumn";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: true;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            pgColumnBuilderBrand: 'PgCustomColumnBuilderBrand';
+        }>;
+        sandboxId: import("drizzle-orm/pg-core").PgColumn<{
+            name: "sandboxId";
+            tableName: "sandbox_signals";
+            dataType: "custom";
+            columnType: "PgCustomColumn";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            pgColumnBuilderBrand: 'PgCustomColumnBuilderBrand';
+        }>;
+        kind: import("drizzle-orm/pg-core").PgColumn<{
+            name: "kind";
+            tableName: "sandbox_signals";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        timer: import("drizzle-orm/pg-core").PgColumn<{
+            name: "timer";
+            tableName: "sandbox_signals";
+            dataType: "string";
+            columnType: "PgText";
+            data: string;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        at: import("drizzle-orm/pg-core").PgColumn<{
+            name: "at";
+            tableName: "sandbox_signals";
+            dataType: "number";
+            columnType: "PgBigInt53";
+            data: number;
+            driverParam: string | number;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        createdAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "createdAt";
+            tableName: "sandbox_signals";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        attempts: import("drizzle-orm/pg-core").PgColumn<{
+            name: "attempts";
+            tableName: "sandbox_signals";
+            dataType: "number";
+            columnType: "PgInteger";
+            data: number;
+            driverParam: string | number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        retryAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "retryAt";
+            tableName: "sandbox_signals";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+        parkedAt: import("drizzle-orm/pg-core").PgColumn<{
+            name: "parkedAt";
+            tableName: "sandbox_signals";
+            dataType: "date";
+            columnType: "PgTimestamp";
+            data: Date;
+            driverParam: string;
+            notNull: false;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
     };
     dialect: 'pg';
 }>;