@rikalabs/akter-cli 0.1.0-alpha.3 → 0.1.0-alpha.4

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # Changelog
 
+## 0.1.0-alpha.4 (2026-10-09)
+
+- **Breaking cloud contract:** every environment uses customer Postgres through `DATABASE_URL`. `Environment.database`, when reported, is `{ source: "customer", state: "missing" | "reachable" | "unreachable", latency, latencyWarning, runnerCap }`. Latency is nullable p50 milliseconds; runner cap is a nullable integer. The managed source and provisioning, ready, read-only and failed states are removed.
+- **Breaking billing contract:** base subscription plus compute unit-hours only. Removes storage allowances, caps, overage prices, meters, samples, per-project storage usage and managed database features. `QuotaExceeded.cap` is now `compute`, `connections` or `spend`; storage is no longer a quota. All types remain derived from Effect schemas at `@rikalabs/akter-cli/cloud-api`.
+- `akter env list` prints names and update times without a `managed` marker. After a deployment reaches `live`, `akter deploy` confirms success and reads the database report, printing its latency warning and non-null runner cap, including zero, only for the completed rollout. A p50 above 5 ms warns without refusing the deployment; unknown measurements stay unknown. Failed or superseded diagnostic reads warn without changing the successful exit status.
+- `akter deploy` keeps following a rollout through a brief control-plane outage. Transport failures, typed `Unavailable` (503) answers without a known `reason` and unreadable 5xx answers such as a proxy's 502 are retried with the delays `logs --follow` uses (1, 2, 4, then 8 seconds), and six consecutive failed reads stop it as before. Refusals, including an ended session, are never retried.
+- The cloud API contract's `Authentication` middleware declares `Unavailable` (503) alongside `Unauthorized` and `Forbidden`, so every endpoint, including `/api/me`, decodes a session-store outage as a typed `Unavailable`. `akter whoami` then reports a temporary outage (exit 1) instead of an unreachable control plane (exit 2), and never asks you to log in again. This is additive for `/cloud-api` consumers; a server may now fail authentication with `Unavailable`.
+
 ## 0.1.0-alpha.3 (2026-10-08)
 
 The first CLI release, versioned with `@rikalabs/akter` on the `alpha` and `latest` dist-tags. This includes the unpublished alpha.2 draft and the final launch contract.

package/dist/cloud-api/auth.d.ts

@@ -1,6 +1,6 @@
 import { Context, Schema } from "effect";
 import { HttpApiMiddleware, HttpApiSecurity } from "effect/http-api";
-import { Forbidden, Unauthorized } from "./errors.ts";
+import { Forbidden, Unauthorized, Unavailable } from "./errors.ts";
 /** The cookie that carries the Better Auth session token over plain HTTP. */
 export declare const sessionCookieName = "better-auth.session_token";
 /** The same cookie as Better Auth names it when served over HTTPS. */
@@ -46,7 +46,7 @@ export declare class CurrentIdentity extends CurrentIdentity_base {
 declare const Authentication_base: HttpApiMiddleware.ServiceClass<Authentication, "@akter/cloud-api/Authentication", {
     requires: never;
     provides: CurrentIdentity;
-    error: readonly [typeof Unauthorized, typeof Forbidden];
+    error: readonly [typeof Unauthorized, typeof Forbidden, typeof Unavailable];
     clientError: never;
     requiredForClient: false;
     security: {
@@ -60,14 +60,17 @@ declare const Authentication_base: HttpApiMiddleware.ServiceClass<Authentication
     readonly secureSession: HttpApiSecurity.ApiKey;
     readonly apiKey: HttpApiSecurity.ApiKey;
     readonly bearer: HttpApiSecurity.Http;
-}, CurrentIdentity, readonly [typeof Unauthorized, typeof Forbidden], never>>;
+}, CurrentIdentity, readonly [typeof Unauthorized, typeof Forbidden, typeof Unavailable], never>>;
 /**
  * Resolves who is calling. The server implements one handler per security
  * scheme and fails `Unauthorized` when a scheme's credential is missing or
  * invalid; the first scheme that succeeds provides `CurrentIdentity`. A cookie
  * browser client sends credentials automatically, so no client implementation
  * is required. `bearer` carries the session token a CLI receives from Better
- * Auth's device authorization grant.
+ * Auth's device authorization grant. A credential the server cannot check
+ * because its session store is down fails `Unavailable`, never
+ * `Unauthorized`, so every endpoint's client can tell an outage from a
+ * session that ended.
  *
  * @effect-expect-leaking HttpServerRequest | ParsedSearchParams | RouteContext
  */

package/dist/cloud-api/billing.d.ts

@@ -48,16 +48,13 @@ export type SpendLimit = typeof SpendLimit.Type;
  * reported, discriminated by `cap`. `limit` is null when the cap does not
  * apply. `atCap` means usage has reached the limit; `refusing` means the edge
  * would refuse the next new command, or for `connections` the next new
- * connection, or for `storage` that the organization's managed databases are
- * read-only: writes fail and reads still work. `reason` is `unbound` when the
+ * connection. `reason` is `unbound` when the
  * edge refuses everything because the organization has no billing account;
  * such caps have no limit.
  *
  * `limit` and `used` are cents for `spend`, open connections for
  * `connections`, compute unit-hours used in the current billing period for
- * `compute`, and decimal gigabytes for `storage`: the organization's pooled
- * managed database storage, where `used` is the latest pooled sample. A
- * database the customer brings never counts toward it.
+ * `compute`. Customer database storage is not metered, capped or billed.
  */
 export declare const CapState: Schema.Struct<{
     readonly limit: Schema.NullOr<Schema.Finite>;
@@ -65,7 +62,7 @@ export declare const CapState: Schema.Struct<{
     readonly atCap: Schema.Boolean;
     readonly refusing: Schema.Boolean;
     readonly reason: Schema.optionalKey<Schema.Literal<"unbound">>;
-    readonly cap: Schema.Literals<readonly ["spend", "connections", "compute", "storage"]>;
+    readonly cap: Schema.Literals<readonly ["spend", "connections", "compute"]>;
 }>;
 export type CapState = typeof CapState.Type;
 /**
@@ -104,7 +101,7 @@ export declare const BillingSummary: Schema.Struct<{
         readonly atCap: Schema.Boolean;
         readonly refusing: Schema.Boolean;
         readonly reason: Schema.optionalKey<Schema.Literal<"unbound">>;
-        readonly cap: Schema.Literals<readonly ["spend", "connections", "compute", "storage"]>;
+        readonly cap: Schema.Literals<readonly ["spend", "connections", "compute"]>;
     }>>>;
 }>;
 export type BillingSummary = typeof BillingSummary.Type;
@@ -141,11 +138,10 @@ export declare const HostedSession: Schema.Struct<{
 export type HostedSession = typeof HostedSession.Type;
 /**
  * What a plan offers, derived from the pricing configuration: billed compute
- * overage, a hard compute cap, billed storage overage, a hard storage cap, a
- * database the customer brings, a dedicated database, and a paid subscription
- * bought through checkout.
+ * overage, a hard compute cap, customer Postgres on every plan, and a paid
+ * subscription bought through checkout.
  */
-export declare const PlanFeature: Schema.Literals<readonly ["compute-overage", "compute-cap", "storage-overage", "storage-cap", "byo-database", "dedicated-database", "checkout"]>;
+export declare const PlanFeature: Schema.Literals<readonly ["compute-overage", "compute-cap", "byo-database", "checkout"]>;
 export type PlanFeature = typeof PlanFeature.Type;
 /**
  * One tier of the pricing configuration. `allowances.computeUnitHours` is the
@@ -154,12 +150,7 @@ export type PlanFeature = typeof PlanFeature.Type;
  * `overage.computeCentsPerUnitHour`). A machine size's hour bills the compute
  * unit-hours `PlanCatalog.computeSizes` gives it.
  *
- * `allowances.storageGb` is the managed database storage included in the
- * plan, in decimal gigabytes, pooled across the organization's managed
- * environment databases. `allowances.storageGbCap` is its hard stop, past
- * which those databases are read-only, and is null when overage is billed
- * instead at `overage.storageCentsPerGbMonth`. A provisional tier's prices
- * are not yet published.
+ * A provisional tier's prices are not yet published.
  */
 export declare const CatalogPlan: Schema.Struct<{
     readonly id: Schema.Literals<readonly ["free", "pro", "team", "enterprise"]>;
@@ -169,15 +160,12 @@ export declare const CatalogPlan: Schema.Struct<{
     readonly allowances: Schema.Struct<{
         readonly computeUnitHours: Schema.Finite;
         readonly computeUnitHourCap: Schema.NullOr<Schema.Finite>;
-        readonly storageGb: Schema.Finite;
-        readonly storageGbCap: Schema.NullOr<Schema.Finite>;
         readonly concurrentConnections: Schema.Int;
     }>;
     readonly overage: Schema.Struct<{
         readonly computeCentsPerUnitHour: Schema.Finite;
-        readonly storageCentsPerGbMonth: Schema.Finite;
     }>;
-    readonly features: Schema.$Array<Schema.Literals<readonly ["compute-overage", "compute-cap", "storage-overage", "storage-cap", "byo-database", "dedicated-database", "checkout"]>>;
+    readonly features: Schema.$Array<Schema.Literals<readonly ["compute-overage", "compute-cap", "byo-database", "checkout"]>>;
     readonly provisional: Schema.Boolean;
 }>;
 export type CatalogPlan = typeof CatalogPlan.Type;
@@ -207,15 +195,12 @@ export declare const PlanCatalog: Schema.Struct<{
         readonly allowances: Schema.Struct<{
             readonly computeUnitHours: Schema.Finite;
             readonly computeUnitHourCap: Schema.NullOr<Schema.Finite>;
-            readonly storageGb: Schema.Finite;
-            readonly storageGbCap: Schema.NullOr<Schema.Finite>;
             readonly concurrentConnections: Schema.Int;
         }>;
         readonly overage: Schema.Struct<{
             readonly computeCentsPerUnitHour: Schema.Finite;
-            readonly storageCentsPerGbMonth: Schema.Finite;
         }>;
-        readonly features: Schema.$Array<Schema.Literals<readonly ["compute-overage", "compute-cap", "storage-overage", "storage-cap", "byo-database", "dedicated-database", "checkout"]>>;
+        readonly features: Schema.$Array<Schema.Literals<readonly ["compute-overage", "compute-cap", "byo-database", "checkout"]>>;
         readonly provisional: Schema.Boolean;
     }>>;
     readonly computeSizes: Schema.$Array<Schema.Struct<{
@@ -230,13 +215,12 @@ export type PlanCatalog = typeof PlanCatalog.Type;
 /**
  * `runnerHours` is measured in compute unit-hours (see `ComputeUsage`), not
  * machine hours; raw machine hours are reported per machine size in
- * `ComputeUsage.machineHours`. `storageGb` is the average pooled managed
- * database storage over the period in decimal gigabytes, billed per GB-month.
+ * `ComputeUsage.machineHours`.
  */
-export declare const UsageMeterName: Schema.Literals<readonly ["runnerHours", "storageGb"]>;
+export declare const UsageMeterName: Schema.Literal<"runnerHours">;
 export type UsageMeterName = typeof UsageMeterName.Type;
 export declare const UsageMeter: Schema.Struct<{
-    readonly meter: Schema.Literals<readonly ["runnerHours", "storageGb"]>;
+    readonly meter: Schema.Literal<"runnerHours">;
     readonly used: Schema.Finite;
     readonly included: Schema.Finite;
     readonly overage: Schema.Finite;
@@ -246,12 +230,10 @@ export type UsageMeter = typeof UsageMeter.Type;
 /**
  * The published rules usage is priced by, sent with every usage report.
  * `computeCentsPerUnitHour` prices compute unit-hours beyond the plan's
- * allowance and `storageCentsPerGbMonth` prices managed database storage
- * beyond it; each is 0 where the plan bills no overage.
+ * allowance and is 0 where the plan bills no overage.
  */
 export declare const UsagePricing: Schema.Struct<{
     readonly computeCentsPerUnitHour: Schema.Finite;
-    readonly storageCentsPerGbMonth: Schema.Finite;
     readonly provisional: Schema.optionalKey<Schema.Boolean>;
 }>;
 export type UsagePricing = typeof UsagePricing.Type;
@@ -269,42 +251,27 @@ export declare const ComputeUsage: Schema.Struct<{
     readonly computeUnitHours: Schema.Finite;
 }>;
 export type ComputeUsage = typeof ComputeUsage.Type;
-/**
- * The organization's latest pooled managed database storage: the sum of the
- * sampled bytes of its managed environment databases, and when it was
- * sampled. A database the customer brings is excluded.
- */
-export declare const StorageSample: Schema.Struct<{
-    readonly bytes: Schema.Finite;
-    readonly sampledAt: Schema.DateTimeUtc;
-}>;
-export type StorageSample = typeof StorageSample.Type;
 /**
  * `caps` describe now whatever `period` is reported. A project's
  * `computeUnitHours` is its compute for the period and `compute` breaks it
- * down by environment and machine size; its `storageGbMonths` is its managed
- * databases' storage for the period.
+ * down by environment and machine size.
  */
 export declare const Usage: Schema.Struct<{
     readonly period: Schema.String;
     readonly meters: Schema.$Array<Schema.Struct<{
-        readonly meter: Schema.Literals<readonly ["runnerHours", "storageGb"]>;
+        readonly meter: Schema.Literal<"runnerHours">;
         readonly used: Schema.Finite;
         readonly included: Schema.Finite;
         readonly overage: Schema.Finite;
         readonly overageCostCents: Schema.Finite;
     }>>;
-    readonly latestStorageSample: Schema.NullOr<Schema.Struct<{
-        readonly bytes: Schema.Finite;
-        readonly sampledAt: Schema.DateTimeUtc;
-    }>>;
     readonly caps: Schema.$Array<Schema.Struct<{
         readonly limit: Schema.NullOr<Schema.Finite>;
         readonly used: Schema.Finite;
         readonly atCap: Schema.Boolean;
         readonly refusing: Schema.Boolean;
         readonly reason: Schema.optionalKey<Schema.Literal<"unbound">>;
-        readonly cap: Schema.Literals<readonly ["spend", "connections", "compute", "storage"]>;
+        readonly cap: Schema.Literals<readonly ["spend", "connections", "compute"]>;
     }>>;
     readonly byProject: Schema.$Array<Schema.Struct<{
         readonly projectId: Schema.brand<Schema.String, "ProjectId">;
@@ -318,12 +285,10 @@ export declare const Usage: Schema.Struct<{
             readonly machineHours: Schema.Finite;
             readonly computeUnitHours: Schema.Finite;
         }>>;
-        readonly storageGbMonths: Schema.Finite;
         readonly estimatedCostCents: Schema.Finite;
     }>>;
     readonly pricing: Schema.Struct<{
         readonly computeCentsPerUnitHour: Schema.Finite;
-        readonly storageCentsPerGbMonth: Schema.Finite;
         readonly provisional: Schema.optionalKey<Schema.Boolean>;
     }>;
 }>;

package/dist/cloud-api/contract.d.ts

@@ -232,7 +232,7 @@ declare const CloudApi_base: HttpApi.HttpApi<"akter-cloud", import("effect/http-
         readonly atCap: import("effect/Schema").Boolean;
         readonly refusing: import("effect/Schema").Boolean;
         readonly reason: import("effect/Schema").optionalKey<import("effect/Schema").Literal<"unbound">>;
-        readonly cap: import("effect/Schema").Literals<readonly ["spend", "connections", "compute", "storage"]>;
+        readonly cap: import("effect/Schema").Literals<readonly ["spend", "connections", "compute"]>;
     }>>>;
 }>>, import("effect/Schema").toCodecJson<typeof import("./errors.ts").Forbidden | typeof import("./errors.ts").NotFound | typeof import("./errors.ts").NotImplemented | typeof import("./errors.ts").Unavailable>, Authentication, never> | import("effect/http-api/HttpApiEndpoint").HttpApiEndpoint<"listInvoices", "GET", "/api/organizations/:organizationId/billing/invoices", import("effect/Schema").toCodecStringTree<import("effect/Schema").Struct<{
     organizationId: import("effect/Schema").brand<import("effect/Schema").String, "OrganizationId">;
@@ -254,15 +254,12 @@ declare const CloudApi_base: HttpApi.HttpApi<"akter-cloud", import("effect/http-
         readonly allowances: import("effect/Schema").Struct<{
             readonly computeUnitHours: import("effect/Schema").Finite;
             readonly computeUnitHourCap: import("effect/Schema").NullOr<import("effect/Schema").Finite>;
-            readonly storageGb: import("effect/Schema").Finite;
-            readonly storageGbCap: import("effect/Schema").NullOr<import("effect/Schema").Finite>;
             readonly concurrentConnections: import("effect/Schema").Int;
         }>;
         readonly overage: import("effect/Schema").Struct<{
             readonly computeCentsPerUnitHour: import("effect/Schema").Finite;
-            readonly storageCentsPerGbMonth: import("effect/Schema").Finite;
         }>;
-        readonly features: import("effect/Schema").$Array<import("effect/Schema").Literals<readonly ["compute-overage", "compute-cap", "storage-overage", "storage-cap", "byo-database", "dedicated-database", "checkout"]>>;
+        readonly features: import("effect/Schema").$Array<import("effect/Schema").Literals<readonly ["compute-overage", "compute-cap", "byo-database", "checkout"]>>;
         readonly provisional: import("effect/Schema").Boolean;
     }>>;
     readonly computeSizes: import("effect/Schema").$Array<import("effect/Schema").Struct<{
@@ -902,8 +899,11 @@ declare const CloudApi_base: HttpApi.HttpApi<"akter-cloud", import("effect/http-
     readonly projectId: import("effect/Schema").brand<import("effect/Schema").String, "ProjectId">;
     readonly currentDeploymentId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, "DeploymentId">>;
     readonly database: import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
-        readonly source: import("effect/Schema").Literals<readonly ["managed", "customer"]>;
-        readonly state: import("effect/Schema").Literals<readonly ["provisioning", "ready", "read-only", "failed"]>;
+        readonly source: import("effect/Schema").Literal<"customer">;
+        readonly state: import("effect/Schema").Literals<readonly ["missing", "reachable", "unreachable"]>;
+        readonly latency: import("effect/Schema").NullOr<import("effect/Schema").Finite>;
+        readonly latencyWarning: import("effect/Schema").Boolean;
+        readonly runnerCap: import("effect/Schema").NullOr<import("effect/Schema").Int>;
     }>>;
 }>>, import("effect/Schema").toCodecJson<typeof import("./errors.ts").Forbidden | typeof import("./errors.ts").NotFound | typeof import("./errors.ts").Conflict | typeof import("./errors.ts").NotImplemented | typeof import("./errors.ts").Unavailable>, Authentication, never> | import("effect/http-api/HttpApiEndpoint").HttpApiEndpoint<"delete", "DELETE", "/api/projects/:projectId", import("effect/Schema").toCodecStringTree<import("effect/Schema").Struct<{
     projectId: import("effect/Schema").brand<import("effect/Schema").String, "ProjectId">;
@@ -936,8 +936,11 @@ declare const CloudApi_base: HttpApi.HttpApi<"akter-cloud", import("effect/http-
     readonly projectId: import("effect/Schema").brand<import("effect/Schema").String, "ProjectId">;
     readonly currentDeploymentId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, "DeploymentId">>;
     readonly database: import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
-        readonly source: import("effect/Schema").Literals<readonly ["managed", "customer"]>;
-        readonly state: import("effect/Schema").Literals<readonly ["provisioning", "ready", "read-only", "failed"]>;
+        readonly source: import("effect/Schema").Literal<"customer">;
+        readonly state: import("effect/Schema").Literals<readonly ["missing", "reachable", "unreachable"]>;
+        readonly latency: import("effect/Schema").NullOr<import("effect/Schema").Finite>;
+        readonly latencyWarning: import("effect/Schema").Boolean;
+        readonly runnerCap: import("effect/Schema").NullOr<import("effect/Schema").Int>;
     }>>;
 }>>, import("effect/Schema").toCodecJson<typeof import("./errors.ts").Forbidden | typeof import("./errors.ts").NotFound | typeof import("./errors.ts").NotImplemented | typeof import("./errors.ts").Unavailable>, Authentication, never> | import("effect/http-api/HttpApiEndpoint").HttpApiEndpoint<"list", "GET", "/api/organizations/:organizationId/projects", import("effect/Schema").toCodecStringTree<import("effect/Schema").Struct<{
     organizationId: import("effect/Schema").brand<import("effect/Schema").String, "OrganizationId">;
@@ -956,8 +959,11 @@ declare const CloudApi_base: HttpApi.HttpApi<"akter-cloud", import("effect/http-
     readonly projectId: import("effect/Schema").brand<import("effect/Schema").String, "ProjectId">;
     readonly currentDeploymentId: import("effect/Schema").NullOr<import("effect/Schema").brand<import("effect/Schema").String, "DeploymentId">>;
     readonly database: import("effect/Schema").optionalKey<import("effect/Schema").Struct<{
-        readonly source: import("effect/Schema").Literals<readonly ["managed", "customer"]>;
-        readonly state: import("effect/Schema").Literals<readonly ["provisioning", "ready", "read-only", "failed"]>;
+        readonly source: import("effect/Schema").Literal<"customer">;
+        readonly state: import("effect/Schema").Literals<readonly ["missing", "reachable", "unreachable"]>;
+        readonly latency: import("effect/Schema").NullOr<import("effect/Schema").Finite>;
+        readonly latencyWarning: import("effect/Schema").Boolean;
+        readonly runnerCap: import("effect/Schema").NullOr<import("effect/Schema").Int>;
     }>>;
 }>>>, import("effect/Schema").toCodecJson<typeof import("./errors.ts").Forbidden | typeof import("./errors.ts").NotFound | typeof import("./errors.ts").NotImplemented | typeof import("./errors.ts").Unavailable>, Authentication, never> | import("effect/http-api/HttpApiEndpoint").HttpApiEndpoint<"update", "PATCH", "/api/projects/:projectId", import("effect/Schema").toCodecStringTree<import("effect/Schema").Struct<{
     projectId: import("effect/Schema").brand<import("effect/Schema").String, "ProjectId">;
@@ -1505,23 +1511,19 @@ declare const CloudApi_base: HttpApi.HttpApi<"akter-cloud", import("effect/http-
 }>>, never, never, import("effect/Schema").toCodecJson<import("effect/Schema").Struct<{
     readonly period: import("effect/Schema").String;
     readonly meters: import("effect/Schema").$Array<import("effect/Schema").Struct<{
-        readonly meter: import("effect/Schema").Literals<readonly ["runnerHours", "storageGb"]>;
+        readonly meter: import("effect/Schema").Literal<"runnerHours">;
         readonly used: import("effect/Schema").Finite;
         readonly included: import("effect/Schema").Finite;
         readonly overage: import("effect/Schema").Finite;
         readonly overageCostCents: import("effect/Schema").Finite;
     }>>;
-    readonly latestStorageSample: import("effect/Schema").NullOr<import("effect/Schema").Struct<{
-        readonly bytes: import("effect/Schema").Finite;
-        readonly sampledAt: import("effect/Schema").DateTimeUtc;
-    }>>;
     readonly caps: import("effect/Schema").$Array<import("effect/Schema").Struct<{
         readonly limit: import("effect/Schema").NullOr<import("effect/Schema").Finite>;
         readonly used: import("effect/Schema").Finite;
         readonly atCap: import("effect/Schema").Boolean;
         readonly refusing: import("effect/Schema").Boolean;
         readonly reason: import("effect/Schema").optionalKey<import("effect/Schema").Literal<"unbound">>;
-        readonly cap: import("effect/Schema").Literals<readonly ["spend", "connections", "compute", "storage"]>;
+        readonly cap: import("effect/Schema").Literals<readonly ["spend", "connections", "compute"]>;
     }>>;
     readonly byProject: import("effect/Schema").$Array<import("effect/Schema").Struct<{
         readonly projectId: import("effect/Schema").brand<import("effect/Schema").String, "ProjectId">;
@@ -1535,12 +1537,10 @@ declare const CloudApi_base: HttpApi.HttpApi<"akter-cloud", import("effect/http-
             readonly machineHours: import("effect/Schema").Finite;
             readonly computeUnitHours: import("effect/Schema").Finite;
         }>>;
-        readonly storageGbMonths: import("effect/Schema").Finite;
         readonly estimatedCostCents: import("effect/Schema").Finite;
     }>>;
     readonly pricing: import("effect/Schema").Struct<{
         readonly computeCentsPerUnitHour: import("effect/Schema").Finite;
-        readonly storageCentsPerGbMonth: import("effect/Schema").Finite;
         readonly provisional: import("effect/Schema").optionalKey<import("effect/Schema").Boolean>;
     }>;
 }>>, import("effect/Schema").toCodecJson<typeof import("./errors.ts").Forbidden | typeof import("./errors.ts").NotFound | typeof import("./errors.ts").NotImplemented | typeof import("./errors.ts").Unavailable>, Authentication, never>, false>>;

package/dist/cloud-api/groups/billing.d.ts

@@ -40,7 +40,7 @@ declare const BillingGroup_base: HttpApiGroup.HttpApiGroup<"billing", HttpApiEnd
         readonly atCap: Schema.Boolean;
         readonly refusing: Schema.Boolean;
         readonly reason: Schema.optionalKey<Schema.Literal<"unbound">>;
-        readonly cap: Schema.Literals<readonly ["spend", "connections", "compute", "storage"]>;
+        readonly cap: Schema.Literals<readonly ["spend", "connections", "compute"]>;
     }>>>;
 }>>, Schema.toCodecJson<typeof import("../errors.ts").Forbidden | typeof import("../errors.ts").NotFound | typeof import("../errors.ts").NotImplemented | typeof import("../errors.ts").Unavailable>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"listInvoices", "GET", "/organizations/:organizationId/billing/invoices", Schema.toCodecStringTree<Schema.Struct<{
     organizationId: Schema.brand<Schema.String, "OrganizationId">;
@@ -62,15 +62,12 @@ declare const BillingGroup_base: HttpApiGroup.HttpApiGroup<"billing", HttpApiEnd
         readonly allowances: Schema.Struct<{
             readonly computeUnitHours: Schema.Finite;
             readonly computeUnitHourCap: Schema.NullOr<Schema.Finite>;
-            readonly storageGb: Schema.Finite;
-            readonly storageGbCap: Schema.NullOr<Schema.Finite>;
             readonly concurrentConnections: Schema.Int;
         }>;
         readonly overage: Schema.Struct<{
             readonly computeCentsPerUnitHour: Schema.Finite;
-            readonly storageCentsPerGbMonth: Schema.Finite;
         }>;
-        readonly features: Schema.$Array<Schema.Literals<readonly ["compute-overage", "compute-cap", "storage-overage", "storage-cap", "byo-database", "dedicated-database", "checkout"]>>;
+        readonly features: Schema.$Array<Schema.Literals<readonly ["compute-overage", "compute-cap", "byo-database", "checkout"]>>;
         readonly provisional: Schema.Boolean;
     }>>;
     readonly computeSizes: Schema.$Array<Schema.Struct<{
@@ -107,23 +104,19 @@ declare const UsageGroup_base: HttpApiGroup.HttpApiGroup<"usage", HttpApiEndpoin
 }>>, never, never, Schema.toCodecJson<Schema.Struct<{
     readonly period: Schema.String;
     readonly meters: Schema.$Array<Schema.Struct<{
-        readonly meter: Schema.Literals<readonly ["runnerHours", "storageGb"]>;
+        readonly meter: Schema.Literal<"runnerHours">;
         readonly used: Schema.Finite;
         readonly included: Schema.Finite;
         readonly overage: Schema.Finite;
         readonly overageCostCents: Schema.Finite;
     }>>;
-    readonly latestStorageSample: Schema.NullOr<Schema.Struct<{
-        readonly bytes: Schema.Finite;
-        readonly sampledAt: Schema.DateTimeUtc;
-    }>>;
     readonly caps: Schema.$Array<Schema.Struct<{
         readonly limit: Schema.NullOr<Schema.Finite>;
         readonly used: Schema.Finite;
         readonly atCap: Schema.Boolean;
         readonly refusing: Schema.Boolean;
         readonly reason: Schema.optionalKey<Schema.Literal<"unbound">>;
-        readonly cap: Schema.Literals<readonly ["spend", "connections", "compute", "storage"]>;
+        readonly cap: Schema.Literals<readonly ["spend", "connections", "compute"]>;
     }>>;
     readonly byProject: Schema.$Array<Schema.Struct<{
         readonly projectId: Schema.brand<Schema.String, "ProjectId">;
@@ -137,12 +130,10 @@ declare const UsageGroup_base: HttpApiGroup.HttpApiGroup<"usage", HttpApiEndpoin
             readonly machineHours: Schema.Finite;
             readonly computeUnitHours: Schema.Finite;
         }>>;
-        readonly storageGbMonths: Schema.Finite;
         readonly estimatedCostCents: Schema.Finite;
     }>>;
     readonly pricing: Schema.Struct<{
         readonly computeCentsPerUnitHour: Schema.Finite;
-        readonly storageCentsPerGbMonth: Schema.Finite;
         readonly provisional: Schema.optionalKey<Schema.Boolean>;
     }>;
 }>>, Schema.toCodecJson<typeof import("../errors.ts").Forbidden | typeof import("../errors.ts").NotFound | typeof import("../errors.ts").NotImplemented | typeof import("../errors.ts").Unavailable>, never, never>, false>;

package/dist/cloud-api/groups/projects.d.ts

@@ -23,8 +23,11 @@ declare const ProjectsGroup_base: HttpApiGroup.HttpApiGroup<"projects", HttpApiE
     readonly projectId: Schema.brand<Schema.String, "ProjectId">;
     readonly currentDeploymentId: Schema.NullOr<Schema.brand<Schema.String, "DeploymentId">>;
     readonly database: Schema.optionalKey<Schema.Struct<{
-        readonly source: Schema.Literals<readonly ["managed", "customer"]>;
-        readonly state: Schema.Literals<readonly ["provisioning", "ready", "read-only", "failed"]>;
+        readonly source: Schema.Literal<"customer">;
+        readonly state: Schema.Literals<readonly ["missing", "reachable", "unreachable"]>;
+        readonly latency: Schema.NullOr<Schema.Finite>;
+        readonly latencyWarning: Schema.Boolean;
+        readonly runnerCap: Schema.NullOr<Schema.Int>;
     }>>;
 }>>, Schema.toCodecJson<typeof import("../errors.ts").Forbidden | typeof import("../errors.ts").NotFound | typeof import("../errors.ts").Conflict | typeof import("../errors.ts").NotImplemented | typeof import("../errors.ts").Unavailable>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"delete", "DELETE", "/projects/:projectId", Schema.toCodecStringTree<Schema.Struct<{
     projectId: Schema.brand<Schema.String, "ProjectId">;
@@ -57,8 +60,11 @@ declare const ProjectsGroup_base: HttpApiGroup.HttpApiGroup<"projects", HttpApiE
     readonly projectId: Schema.brand<Schema.String, "ProjectId">;
     readonly currentDeploymentId: Schema.NullOr<Schema.brand<Schema.String, "DeploymentId">>;
     readonly database: Schema.optionalKey<Schema.Struct<{
-        readonly source: Schema.Literals<readonly ["managed", "customer"]>;
-        readonly state: Schema.Literals<readonly ["provisioning", "ready", "read-only", "failed"]>;
+        readonly source: Schema.Literal<"customer">;
+        readonly state: Schema.Literals<readonly ["missing", "reachable", "unreachable"]>;
+        readonly latency: Schema.NullOr<Schema.Finite>;
+        readonly latencyWarning: Schema.Boolean;
+        readonly runnerCap: Schema.NullOr<Schema.Int>;
     }>>;
 }>>, Schema.toCodecJson<typeof import("../errors.ts").Forbidden | typeof import("../errors.ts").NotFound | typeof import("../errors.ts").NotImplemented | typeof import("../errors.ts").Unavailable>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"list", "GET", "/organizations/:organizationId/projects", Schema.toCodecStringTree<Schema.Struct<{
     organizationId: Schema.brand<Schema.String, "OrganizationId">;
@@ -77,8 +83,11 @@ declare const ProjectsGroup_base: HttpApiGroup.HttpApiGroup<"projects", HttpApiE
     readonly projectId: Schema.brand<Schema.String, "ProjectId">;
     readonly currentDeploymentId: Schema.NullOr<Schema.brand<Schema.String, "DeploymentId">>;
     readonly database: Schema.optionalKey<Schema.Struct<{
-        readonly source: Schema.Literals<readonly ["managed", "customer"]>;
-        readonly state: Schema.Literals<readonly ["provisioning", "ready", "read-only", "failed"]>;
+        readonly source: Schema.Literal<"customer">;
+        readonly state: Schema.Literals<readonly ["missing", "reachable", "unreachable"]>;
+        readonly latency: Schema.NullOr<Schema.Finite>;
+        readonly latencyWarning: Schema.Boolean;
+        readonly runnerCap: Schema.NullOr<Schema.Int>;
     }>>;
 }>>>, Schema.toCodecJson<typeof import("../errors.ts").Forbidden | typeof import("../errors.ts").NotFound | typeof import("../errors.ts").NotImplemented | typeof import("../errors.ts").Unavailable>, never, never> | HttpApiEndpoint.HttpApiEndpoint<"update", "PATCH", "/projects/:projectId", Schema.toCodecStringTree<Schema.Struct<{
     projectId: Schema.brand<Schema.String, "ProjectId">;

package/dist/cloud-api/index.d.ts

@@ -5,7 +5,7 @@ export { ApiKey, ApiKeyPermission, CreateApiKey, CreateInvitation, CreateOrganiz
 export { AddDomain, AddRegion, ConnectIntegration, CreateEnvironment, CreateProject, DnsRecord, Domain, DomainStatus, EnvVariable, EnvVariableName, Environment, Hostname, ImportEnvVariables, ImportEnvVariablesResult, Integration, IntegrationConnection, IntegrationKind, OwnedTable, Project, ProjectEndpoints, ProjectRegion, ProjectStatus, Region, SetEnvVariable, SetHomeRegion, UpdateProject, } from "./projects.ts";
 export { BuildLog, BuildLogLine, CreateDeployment, DeploymentAuthor, DeploymentDetail, DeploymentRunner, DeploymentSource, DeploymentStatus, DeploymentSummary, ImageDigest, MAX_SOURCE_BYTES, RecordBuild, FailBuild, RolloutStep, RolloutStepName, SOURCE_ENTRY, SourceArchive, SourceDigest, } from "./deployments.ts";
 export { ActorEvent, ActorInspector, ActorInstance, ActorJob, ActorTimelineEntry, ActorTypeActivity, ActorTypeSummary, CommandCaller, CommandFailed, CommandRefused, CommandExpired, RunnerDefect, CommandStreamGap, CommandLogEntry, QuotaErrors, QuotaExceeded, QuotaUnbound, CommandOutcome, CommandSent, CommandVolume, ConnectionsSummary, DeadLetter, JobStatus, JobTypeStats, JobsSummary, LatencyBucket, Overview, OwnedTableRows, Receipt, Schedule, SearchResult, SendCommand, SeriesWindow, SidebarCounts, TimersSummary, TurnLatency, Workflow, } from "./runtime.ts";
-export { AuditEntry, BillingSummary, CapState, CardPaymentMethod, CatalogPlan, ComputeSize, ComputeUsage, PlanCatalog, PlanFeature, StorageSample, HostedSession, Invoice, LinkPaymentMethod, PaymentMethod, Plan, SetSpendLimit, SpendLimit, StartCheckout, PlanChange, Usage, UsageMeter, UsageMeterName, UsagePricing, } from "./billing.ts";
+export { AuditEntry, BillingSummary, CapState, CardPaymentMethod, CatalogPlan, ComputeSize, ComputeUsage, PlanCatalog, PlanFeature, HostedSession, Invoice, LinkPaymentMethod, PaymentMethod, Plan, SetSpendLimit, SpendLimit, StartCheckout, PlanChange, Usage, UsageMeter, UsageMeterName, UsagePricing, } from "./billing.ts";
 export { CloudApi } from "./contract.ts";
 export { LogCursor, LogLimit, LogWait, MAX_LOG_LINES, MAX_LOG_TEXT_BYTES, MAX_LOG_WAIT_SECONDS, MAX_LOG_WINDOW_SECONDS, RunnerLogLine, RunnerLogPage, logQuery, } from "./logs.ts";
 export { AccountGroup, ApiKeysGroup, InvitationsGroup, MembersGroup, OrganizationsGroup, } from "./groups/account.ts";

package/dist/cloud-api/index.js

@@ -118,7 +118,7 @@ class Authentication extends HttpApiMiddleware.Service()("@akter/cloud-api/Authe
     apiKey: HttpApiSecurity.apiKey({ key: apiKeyHeaderName, in: "header" }),
     bearer: HttpApiSecurity.bearer
   },
-  error: [Unauthorized, Forbidden]
+  error: [Unauthorized, Forbidden, Unavailable]
 }) {
 }
 // ../../packages/cloud-api/src/identity.ts
@@ -310,8 +310,11 @@ var Environment = Schema5.Struct({
   projectId: ProjectId,
   currentDeploymentId: Schema5.NullOr(DeploymentId),
   database: Schema5.optionalKey(Schema5.Struct({
-    source: Schema5.Literals(["managed", "customer"]),
-    state: Schema5.Literals(["provisioning", "ready", "read-only", "failed"])
+    source: Schema5.Literal("customer"),
+    state: Schema5.Literals(["missing", "reachable", "unreachable"]),
+    latency: Schema5.NullOr(NonNegative),
+    latencyWarning: Schema5.Boolean,
+    runnerCap: Schema5.NullOr(Schema5.Int)
   }))
 });
 var CreateEnvironment = Schema5.Struct({ name: EnvironmentName });
@@ -782,7 +785,7 @@ var capFields = {
   reason: Schema8.optionalKey(Schema8.Literal("unbound"))
 };
 var CapState = Schema8.Struct({
-  cap: Schema8.Literals(["spend", "connections", "compute", "storage"]),
+  cap: Schema8.Literals(["spend", "connections", "compute"]),
   ...capFields
 });
 var BillingSummary = Schema8.Struct({
@@ -817,10 +820,7 @@ var machineSizeFields = {
 var PlanFeature = Schema8.Literals([
   "compute-overage",
   "compute-cap",
-  "storage-overage",
-  "storage-cap",
   "byo-database",
-  "dedicated-database",
   "checkout"
 ]);
 var CatalogPlan = Schema8.Struct({
@@ -831,13 +831,10 @@ var CatalogPlan = Schema8.Struct({
   allowances: Schema8.Struct({
     computeUnitHours: NonNegative,
     computeUnitHourCap: Schema8.NullOr(NonNegative),
-    storageGb: NonNegative,
-    storageGbCap: Schema8.NullOr(NonNegative),
     concurrentConnections: NonNegativeInt
   }),
   overage: Schema8.Struct({
-    computeCentsPerUnitHour: NonNegative,
-    storageCentsPerGbMonth: NonNegative
+    computeCentsPerUnitHour: NonNegative
   }),
   features: Schema8.Array(PlanFeature),
   provisional: Schema8.Boolean
@@ -851,7 +848,7 @@ var PlanCatalog = Schema8.Struct({
   computeSizes: Schema8.Array(ComputeSize),
   provisional: Schema8.Boolean
 });
-var UsageMeterName = Schema8.Literals(["runnerHours", "storageGb"]);
+var UsageMeterName = Schema8.Literal("runnerHours");
 var UsageMeter = Schema8.Struct({
   meter: UsageMeterName,
   used: NonNegative,
@@ -861,7 +858,6 @@ var UsageMeter = Schema8.Struct({
 });
 var UsagePricing = Schema8.Struct({
   computeCentsPerUnitHour: NonNegative,
-  storageCentsPerGbMonth: NonNegative,
   provisional: Schema8.optionalKey(Schema8.Boolean)
 });
 var ComputeUsage = Schema8.Struct({
@@ -870,18 +866,15 @@ var ComputeUsage = Schema8.Struct({
   machineHours: NonNegative,
   computeUnitHours: NonNegative
 });
-var StorageSample = Schema8.Struct({ bytes: NonNegative, sampledAt: Timestamp });
 var Usage = Schema8.Struct({
   period: BillingPeriod,
   meters: Schema8.Array(UsageMeter),
-  latestStorageSample: Schema8.NullOr(StorageSample),
   caps: Schema8.Array(CapState),
   byProject: Schema8.Array(Schema8.Struct({
     projectId: ProjectId,
     name: Schema8.String,
     computeUnitHours: NonNegative,
     compute: Schema8.Array(ComputeUsage),
-    storageGbMonths: NonNegative,
     estimatedCostCents: NonNegative
   })),
   pricing: UsagePricing
@@ -1613,7 +1606,6 @@ export {
   SourceDigest,
   SpendLimit,
   StartCheckout,
-  StorageSample,
   Theme,
   TimersSummary,
   Timestamp,

package/dist/cloud-api/projects.d.ts

@@ -28,18 +28,23 @@ export declare const UpdateProject: Schema.Struct<{
 }>;
 export type UpdateProject = typeof UpdateProject.Type;
 /**
- * `database` says only whose database the environment runs on and its state:
- * Akter's `managed` one, which can be provisioning, ready, read-only or
- * failed, or the `customer`'s own, which is always ready once set. It carries
- * no URL or URL-derived field.
+ * Every environment uses the customer's Postgres through `DATABASE_URL`.
+ * `latency` is the deploy probe's p50 in milliseconds from the runner region,
+ * null when unmeasured. Above 5 ms, `latencyWarning` warns without refusing.
+ * `runnerCap` is floor((max_connections - in_use - 10) / 9), null when unknown;
+ * a non-positive cap means no runner fits the available connection budget.
+ * The status carries no URL or URL-derived field.
  */
 export declare const Environment: Schema.Struct<{
     readonly name: Schema.Literals<readonly ["production", "staging", "dev"]>;
     readonly projectId: Schema.brand<Schema.String, "ProjectId">;
     readonly currentDeploymentId: Schema.NullOr<Schema.brand<Schema.String, "DeploymentId">>;
     readonly database: Schema.optionalKey<Schema.Struct<{
-        readonly source: Schema.Literals<readonly ["managed", "customer"]>;
-        readonly state: Schema.Literals<readonly ["provisioning", "ready", "read-only", "failed"]>;
+        readonly source: Schema.Literal<"customer">;
+        readonly state: Schema.Literals<readonly ["missing", "reachable", "unreachable"]>;
+        readonly latency: Schema.NullOr<Schema.Finite>;
+        readonly latencyWarning: Schema.Boolean;
+        readonly runnerCap: Schema.NullOr<Schema.Int>;
     }>>;
 }>;
 export type Environment = typeof Environment.Type;

package/dist/cloud-api/runtime.d.ts

@@ -424,7 +424,7 @@ export declare class CommandFailed extends CommandFailed_base {
 declare const QuotaExceeded_base: Schema.Class<QuotaExceeded, Schema.TaggedStruct<"QuotaExceeded", {
     readonly organizationId: Schema.String;
     readonly period: Schema.String;
-    readonly cap: Schema.Literals<readonly ["compute", "storage", "connections", "spend"]>;
+    readonly cap: Schema.Literals<readonly ["compute", "connections", "spend"]>;
     readonly limit: Schema.Finite;
     readonly used: Schema.Finite;
     readonly retryAfterMs: Schema.Finite;