@nylorun/runtime 0.21.1-beta → 0.23.0-beta

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

@@ -1048,14 +1048,14 @@ export declare const vaultCredentials: import("drizzle-orm/pg-core").PgTableWith
             tableName: "vault_credentials";
             dataType: "string";
             columnType: "PgText";
-            data: "bearer" | "headers" | "model";
+            data: "bearer" | "environment_secret" | "environment_variable" | "headers" | "model";
             driverParam: string;
             notNull: true;
             hasDefault: false;
             isPrimaryKey: false;
             isAutoincrement: false;
             hasRuntimeDefault: false;
-            enumValues: ["bearer", "headers", "model"];
+            enumValues: ["bearer", "headers", "environment_secret", "environment_variable", "model"];
             baseColumn: never;
             identity: undefined;
             generated: undefined;
@@ -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';
 }>;

package/dist/store/postgres/schema.js

@@ -129,7 +129,7 @@ export const vaultCredentials = nylorun.table("vault_credentials", {
     id: textC().primaryKey(),
     vaultId: text().notNull(),
     name: text().notNull(),
-    type: text({ enum: ["bearer", "headers", "model"] }).notNull(),
+    type: text({ enum: ["bearer", "headers", "environment_secret", "environment_variable", "model"] }).notNull(),
     /** JSON text of the non-secret binding: url (and via, identity, header names), or provider and model. */
     bindingJson: text().notNull(),
     expiresAt: text(),
@@ -406,7 +406,8 @@ export const definitionFileUses = nylorun.table("definition_file_uses", {
  * 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 const controlSignals = nylorun.table("control_signals", {
     id: bigint({ mode: "number" }).primaryKey().generatedAlwaysAsIdentity(),
@@ -417,16 +418,20 @@ export const controlSignals = nylorun.table("control_signals", {
     createdAt: timestamp({ withTimezone: true, mode: "string" })
         .notNull()
         .default(sql `clock_timestamp()`),
+    sandboxId: textC(),
+    epoch: integer(),
 }, (t) => [
     index("control_signals_created_at").on(t.createdAt),
-    check("control_signals_kind_check", sql `${t.kind} IN ('session.cancel', 'sessions.reset')`),
+    check("control_signals_kind_check", sql `${t.kind} IN ('session.cancel', 'sessions.reset', 'host.revoked')`),
 ]);
 /**
  * The wake outbox (architecture §12.3): one row per wake a committed transaction asked for
  * (`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 const wakes = nylorun.table("wakes", {
     id: textC().primaryKey(),
@@ -436,7 +441,33 @@ export const wakes = nylorun.table("wakes", {
     createdAt: timestamp({ withTimezone: true, mode: "date" })
         .notNull()
         .default(sql `clock_timestamp()`),
+    attempts: integer().notNull().default(0),
+    retryAt: timestamp({ withTimezone: true, mode: "date" }),
+    parkedAt: timestamp({ withTimezone: true, mode: "date" }),
 }, (t) => [index("wakes_created_at").on(t.createdAt)]);
+/**
+ * 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 const sandboxSignals = nylorun.table("sandbox_signals", {
+    id: textC().primaryKey(),
+    sandboxId: textC().notNull(),
+    kind: text().notNull(),
+    timer: text(),
+    at: bigint({ mode: "number" }),
+    createdAt: timestamp({ withTimezone: true, mode: "date" })
+        .notNull()
+        .default(sql `clock_timestamp()`),
+    attempts: integer().notNull().default(0),
+    retryAt: timestamp({ withTimezone: true, mode: "date" }),
+    parkedAt: timestamp({ withTimezone: true, mode: "date" }),
+}, (t) => [
+    index("sandbox_signals_created_at").on(t.createdAt),
+    check("sandbox_signals_kind_check", sql `${t.kind} IN ('reconcile', 'arm')`),
+]);
 // ---------------------------------------------------------------------------
 // nylorun_streams: the record
 /**