@amerged/ohmyhost-cli 0.1.40 → 0.1.42

package/src/apps/product-cli/src/product-api.ts

@@ -20,6 +20,36 @@ import {
   type ProjectDatabaseWriteReceipt,
 } from "@ohmyhost/contracts/database-access";
 import { assertDatabaseCompute, type DatabaseCompute } from "@ohmyhost/contracts/database-compute";
+import {
+  assertDatabaseExecutionUsagePage,
+  assertDatabaseSchedule,
+  assertDatabaseSchedulePage,
+  assertDatabaseScheduleDeleted,
+  assertDatabaseScheduleRunAccepted,
+  assertDatabaseScheduleRunPage,
+  assertDatabaseWebhook,
+  assertDatabaseWebhookCreated,
+  assertDatabaseWebhookDeleted,
+  assertDatabaseWebhookDeliveryPage,
+  assertDatabaseWebhookPage,
+  assertDatabaseWebhookReplayAccepted,
+  assertDatabaseWebhookTest,
+  type DatabaseExecutionUsagePage,
+  type DatabaseSchedule,
+  type DatabaseScheduleDeleted,
+  type DatabaseSchedulePage,
+  type DatabaseScheduleRunAccepted,
+  type DatabaseScheduleRunPage,
+  type DatabaseScheduleSetRequest,
+  type DatabaseWebhook,
+  type DatabaseWebhookCreated,
+  type DatabaseWebhookDeleted,
+  type DatabaseWebhookDeliveryPage,
+  type DatabaseWebhookEventType,
+  type DatabaseWebhookPage,
+  type DatabaseWebhookReplayAccepted,
+  type DatabaseWebhookTestResult,
+} from "@ohmyhost/contracts/database-events";
 import type { DatabaseComputeSelection } from "@ohmyhost/contracts/database-sizes";
 import {
   assertProjectContext,
@@ -117,6 +147,20 @@ import {
   createProjectDatabaseAccess,
   listProjectDatabaseAccess,
   revokeProjectDatabaseAccess,
+  createProjectDatabaseWebhook,
+  listProjectDatabaseWebhooks,
+  getProjectDatabaseWebhook,
+  deleteProjectDatabaseWebhook,
+  testProjectDatabaseWebhook,
+  listProjectDatabaseWebhookDeliveries,
+  replayProjectDatabaseWebhookDelivery,
+  setProjectDatabaseSchedule,
+  listProjectDatabaseSchedules,
+  getProjectDatabaseSchedule,
+  deleteProjectDatabaseSchedule,
+  listProjectDatabaseScheduleRuns,
+  runProjectDatabaseSchedule,
+  getProjectDatabaseExecutionUsage,
   reconcileOperation,
   streamOperationEvents,
   type DeploymentPlan,
@@ -230,11 +274,7 @@ export interface ProductApi {
     organizationId: string,
   ): Promise<import("@ohmyhost/sdk-ts").OrganizationReferral>;
   getOrganizationCredits(organizationId: string): Promise<OrganizationCredits>;
-  getOrganizationCreditUsage(input: {
-    organizationId: string;
-    month: string;
-    cursor?: string;
-  }): Promise<OrganizationCreditUsage>;
+  getOrganizationCreditUsage(organizationId: string): Promise<OrganizationCreditUsage>;
   getProjectCreditBudget(projectId: string): Promise<ProjectCreditBudget>;
   setProjectCreditBudget(input: {
     projectId: string;
@@ -283,6 +323,85 @@ export interface ProductApi {
     readonly projectId: string;
     readonly accessId: string;
   }): Promise<ProjectDatabaseAccess>;
+  createProjectDatabaseWebhook(input: {
+    readonly projectId: string;
+    readonly environment: "dev" | "prod";
+    readonly idempotencyKey: string;
+    readonly url: string;
+    readonly eventTypes: readonly DatabaseWebhookEventType[];
+    readonly headers: Readonly<Record<string, string>>;
+  }): Promise<DatabaseWebhookCreated>;
+  listProjectDatabaseWebhooks(input: {
+    readonly projectId: string;
+    readonly environment: "dev" | "prod";
+  }): Promise<DatabaseWebhookPage>;
+  getProjectDatabaseWebhook(input: {
+    readonly projectId: string;
+    readonly environment: "dev" | "prod";
+    readonly webhookId: string;
+  }): Promise<DatabaseWebhook>;
+  deleteProjectDatabaseWebhook(input: {
+    readonly projectId: string;
+    readonly environment: "dev" | "prod";
+    readonly webhookId: string;
+  }): Promise<DatabaseWebhookDeleted>;
+  testProjectDatabaseWebhook(input: {
+    readonly projectId: string;
+    readonly environment: "dev" | "prod";
+    readonly webhookId: string;
+  }): Promise<DatabaseWebhookTestResult>;
+  listProjectDatabaseWebhookDeliveries(input: {
+    readonly projectId: string;
+    readonly environment: "dev" | "prod";
+    readonly webhookId?: string;
+    readonly limit?: number;
+    readonly cursor?: string;
+  }): Promise<DatabaseWebhookDeliveryPage>;
+  replayProjectDatabaseWebhookDelivery(input: {
+    readonly projectId: string;
+    readonly environment: "dev" | "prod";
+    readonly deliveryId: string;
+  }): Promise<DatabaseWebhookReplayAccepted>;
+  setProjectDatabaseSchedule(input: {
+    readonly projectId: string;
+    readonly environment: "dev" | "prod";
+    readonly name: string;
+    readonly request: DatabaseScheduleSetRequest;
+  }): Promise<DatabaseSchedule>;
+  listProjectDatabaseSchedules(input: {
+    readonly projectId: string;
+    readonly environment: "dev" | "prod";
+  }): Promise<DatabaseSchedulePage>;
+  getProjectDatabaseSchedule(input: {
+    readonly projectId: string;
+    readonly environment: "dev" | "prod";
+    readonly name: string;
+  }): Promise<DatabaseSchedule>;
+  deleteProjectDatabaseSchedule(input: {
+    readonly projectId: string;
+    readonly environment: "dev" | "prod";
+    readonly name: string;
+  }): Promise<DatabaseScheduleDeleted>;
+  listProjectDatabaseScheduleRuns(input: {
+    readonly projectId: string;
+    readonly environment: "dev" | "prod";
+    readonly name: string;
+    readonly limit?: number;
+  }): Promise<DatabaseScheduleRunPage>;
+  runProjectDatabaseSchedule(input: {
+    readonly projectId: string;
+    readonly environment: "dev" | "prod";
+    readonly name: string;
+  }): Promise<DatabaseScheduleRunAccepted>;
+  getProjectDatabaseExecutionUsage(input: {
+    readonly projectId: string;
+    readonly environment: "dev" | "prod";
+    readonly from: string;
+    readonly to: string;
+    readonly granularity: "hour" | "day";
+    readonly limit?: number;
+    readonly cursor?: string;
+  }): Promise<DatabaseExecutionUsagePage>;
   planPaidDomain(input: {
     readonly projectId: string;
     readonly hostname: string;
@@ -445,6 +564,11 @@ export interface ProductApi {
   managedMail?(input: ManagedMailCommand): Promise<unknown>;
 }
 
+/** A webhook answer that names another environment, webhook or delivery than the request did. */
+const WEBHOOK_SCOPE_MISMATCH = "Webhook response scope mismatch";
+/** A schedule answer that names another environment or schedule than the request did. */
+const SCHEDULE_SCOPE_MISMATCH = "Schedule response scope mismatch";
+
 export class GeneratedSdkProductApi implements ProductApi {
   readonly #client: OhMyHostClient;
   public readonly managedSource: ManagedSourceApi;
@@ -614,15 +738,9 @@ export class GeneratedSdkProductApi implements ProductApi {
       { client: this.#client },
     );
   }
-  public getOrganizationCreditUsage(
-    input: Parameters<ProductApi["getOrganizationCreditUsage"]>[0],
-  ) {
+  public getOrganizationCreditUsage(organizationId: string) {
     return getOrganizationCreditUsage(
-      {
-        organization_id: input.organizationId,
-        month: input.month,
-        ...(input.cursor ? { cursor: input.cursor } : {}),
-      },
+      { organization_id: organizationId },
       { client: this.#client },
     );
   }
@@ -771,6 +889,241 @@ export class GeneratedSdkProductApi implements ProductApi {
     return value;
   }
 
+  /** The signing secret exists only in this answer; the CLI prints it once and stores nothing. */
+  public async createProjectDatabaseWebhook(
+    input: Parameters<ProductApi["createProjectDatabaseWebhook"]>[0],
+  ): Promise<DatabaseWebhookCreated> {
+    const value = await createProjectDatabaseWebhook(
+      {
+        project_id: input.projectId,
+        environment: input.environment,
+        "Idempotency-Key": input.idempotencyKey,
+        databaseWebhookCreateRequest: {
+          url: input.url,
+          event_types: [...input.eventTypes],
+          headers: { ...input.headers },
+        },
+      },
+      { client: this.#client },
+    );
+    assertDatabaseWebhookCreated(value);
+    if (value.environment !== input.environment) throw new TypeError(WEBHOOK_SCOPE_MISMATCH);
+    return value;
+  }
+
+  public async listProjectDatabaseWebhooks(
+    input: Parameters<ProductApi["listProjectDatabaseWebhooks"]>[0],
+  ): Promise<DatabaseWebhookPage> {
+    const value = await listProjectDatabaseWebhooks(
+      { project_id: input.projectId, environment: input.environment },
+      { client: this.#client },
+    );
+    assertDatabaseWebhookPage(value);
+    if (value.items.some((item) => item.environment !== input.environment))
+      throw new TypeError(WEBHOOK_SCOPE_MISMATCH);
+    return value;
+  }
+
+  public async getProjectDatabaseWebhook(
+    input: Parameters<ProductApi["getProjectDatabaseWebhook"]>[0],
+  ): Promise<DatabaseWebhook> {
+    const value = await getProjectDatabaseWebhook(
+      {
+        project_id: input.projectId,
+        environment: input.environment,
+        webhook_id: input.webhookId,
+      },
+      { client: this.#client },
+    );
+    assertDatabaseWebhook(value);
+    if (value.id !== input.webhookId || value.environment !== input.environment)
+      throw new TypeError(WEBHOOK_SCOPE_MISMATCH);
+    return value;
+  }
+
+  public async deleteProjectDatabaseWebhook(
+    input: Parameters<ProductApi["deleteProjectDatabaseWebhook"]>[0],
+  ): Promise<DatabaseWebhookDeleted> {
+    const value = await deleteProjectDatabaseWebhook(
+      {
+        project_id: input.projectId,
+        environment: input.environment,
+        webhook_id: input.webhookId,
+      },
+      { client: this.#client },
+    );
+    assertDatabaseWebhookDeleted(value);
+    if (value.id !== input.webhookId) throw new TypeError(WEBHOOK_SCOPE_MISMATCH);
+    return value;
+  }
+
+  public async testProjectDatabaseWebhook(
+    input: Parameters<ProductApi["testProjectDatabaseWebhook"]>[0],
+  ): Promise<DatabaseWebhookTestResult> {
+    const value = await testProjectDatabaseWebhook(
+      {
+        project_id: input.projectId,
+        environment: input.environment,
+        webhook_id: input.webhookId,
+      },
+      { client: this.#client },
+    );
+    assertDatabaseWebhookTest(value);
+    return value;
+  }
+
+  public async listProjectDatabaseWebhookDeliveries(
+    input: Parameters<ProductApi["listProjectDatabaseWebhookDeliveries"]>[0],
+  ): Promise<DatabaseWebhookDeliveryPage> {
+    const value = await listProjectDatabaseWebhookDeliveries(
+      {
+        project_id: input.projectId,
+        environment: input.environment,
+        ...(input.webhookId === undefined ? {} : { webhook_id: input.webhookId }),
+        ...(input.limit === undefined ? {} : { limit: input.limit }),
+        ...(input.cursor === undefined ? {} : { cursor: input.cursor }),
+      },
+      { client: this.#client },
+    );
+    assertDatabaseWebhookDeliveryPage(value);
+    if (
+      input.webhookId !== undefined &&
+      value.items.some((item) => item.webhook_id !== input.webhookId)
+    )
+      throw new TypeError(WEBHOOK_SCOPE_MISMATCH);
+    return value;
+  }
+
+  public async replayProjectDatabaseWebhookDelivery(
+    input: Parameters<ProductApi["replayProjectDatabaseWebhookDelivery"]>[0],
+  ): Promise<DatabaseWebhookReplayAccepted> {
+    const value = await replayProjectDatabaseWebhookDelivery(
+      {
+        project_id: input.projectId,
+        environment: input.environment,
+        delivery_id: input.deliveryId,
+      },
+      { client: this.#client },
+    );
+    assertDatabaseWebhookReplayAccepted(value);
+    if (value.delivery_id !== input.deliveryId) throw new TypeError(WEBHOOK_SCOPE_MISMATCH);
+    return value;
+  }
+
+  /** A schedule runs the statements as the application's runtime role; the request confirms it. */
+  public async setProjectDatabaseSchedule(
+    input: Parameters<ProductApi["setProjectDatabaseSchedule"]>[0],
+  ): Promise<DatabaseSchedule> {
+    const request = input.request;
+    const value = await setProjectDatabaseSchedule(
+      {
+        project_id: input.projectId,
+        environment: input.environment,
+        name: input.name,
+        databaseScheduleSetRequest: {
+          ...(request.cron === null ? {} : { cron: request.cron }),
+          ...(request.every_seconds === null ? {} : { every_seconds: request.every_seconds }),
+          statements: [...request.statements],
+          timeout_ms: request.timeout_ms,
+          enabled: request.enabled,
+          confirm: true,
+        },
+      },
+      { client: this.#client },
+    );
+    assertDatabaseSchedule(value);
+    if (value.name !== input.name || value.environment !== input.environment)
+      throw new TypeError(SCHEDULE_SCOPE_MISMATCH);
+    return value;
+  }
+
+  public async listProjectDatabaseSchedules(
+    input: Parameters<ProductApi["listProjectDatabaseSchedules"]>[0],
+  ): Promise<DatabaseSchedulePage> {
+    const value = await listProjectDatabaseSchedules(
+      { project_id: input.projectId, environment: input.environment },
+      { client: this.#client },
+    );
+    assertDatabaseSchedulePage(value);
+    if (value.items.some((item) => item.environment !== input.environment))
+      throw new TypeError(SCHEDULE_SCOPE_MISMATCH);
+    return value;
+  }
+
+  public async getProjectDatabaseSchedule(
+    input: Parameters<ProductApi["getProjectDatabaseSchedule"]>[0],
+  ): Promise<DatabaseSchedule> {
+    const value = await getProjectDatabaseSchedule(
+      { project_id: input.projectId, environment: input.environment, name: input.name },
+      { client: this.#client },
+    );
+    assertDatabaseSchedule(value);
+    if (value.name !== input.name || value.environment !== input.environment)
+      throw new TypeError(SCHEDULE_SCOPE_MISMATCH);
+    return value;
+  }
+
+  public async deleteProjectDatabaseSchedule(
+    input: Parameters<ProductApi["deleteProjectDatabaseSchedule"]>[0],
+  ): Promise<DatabaseScheduleDeleted> {
+    const value = await deleteProjectDatabaseSchedule(
+      { project_id: input.projectId, environment: input.environment, name: input.name },
+      { client: this.#client },
+    );
+    assertDatabaseScheduleDeleted(value);
+    if (value.name !== input.name) throw new TypeError(SCHEDULE_SCOPE_MISMATCH);
+    return value;
+  }
+
+  public async listProjectDatabaseScheduleRuns(
+    input: Parameters<ProductApi["listProjectDatabaseScheduleRuns"]>[0],
+  ): Promise<DatabaseScheduleRunPage> {
+    const value = await listProjectDatabaseScheduleRuns(
+      {
+        project_id: input.projectId,
+        environment: input.environment,
+        name: input.name,
+        ...(input.limit === undefined ? {} : { limit: input.limit }),
+      },
+      { client: this.#client },
+    );
+    assertDatabaseScheduleRunPage(value);
+    if (value.items.some((item) => item.schedule !== input.name))
+      throw new TypeError(SCHEDULE_SCOPE_MISMATCH);
+    return value;
+  }
+
+  public async runProjectDatabaseSchedule(
+    input: Parameters<ProductApi["runProjectDatabaseSchedule"]>[0],
+  ): Promise<DatabaseScheduleRunAccepted> {
+    const value = await runProjectDatabaseSchedule(
+      { project_id: input.projectId, environment: input.environment, name: input.name },
+      { client: this.#client },
+    );
+    assertDatabaseScheduleRunAccepted(value);
+    if (value.schedule !== input.name) throw new TypeError(SCHEDULE_SCOPE_MISMATCH);
+    return value;
+  }
+
+  public async getProjectDatabaseExecutionUsage(
+    input: Parameters<ProductApi["getProjectDatabaseExecutionUsage"]>[0],
+  ): Promise<DatabaseExecutionUsagePage> {
+    const value = await getProjectDatabaseExecutionUsage(
+      {
+        project_id: input.projectId,
+        environment: input.environment,
+        from: input.from,
+        to: input.to,
+        granularity: input.granularity,
+        ...(input.limit === undefined ? {} : { limit: input.limit }),
+        ...(input.cursor === undefined ? {} : { cursor: input.cursor }),
+      },
+      { client: this.#client },
+    );
+    assertDatabaseExecutionUsagePage(value);
+    return value;
+  }
+
   public async planPaidDomain(input: {
     readonly projectId: string;
     readonly hostname: string;

package/src/apps/product-cli/src/runtime-contract.ts

@@ -552,9 +552,6 @@ export function parseOrganizationCredits(value: unknown): OrganizationCredits {
     "as_of",
     "available_micros",
     "reserved_micros",
-    "spent_micros",
-    "expired_micros",
-    "platform_overrun_micros",
     "grace_started_at",
     "grace_expires_at",
     "active_meters",
@@ -586,13 +583,7 @@ export function parseOrganizationCredits(value: unknown): OrganizationCredits {
     )
   )
     throw new ResponseContractError();
-  for (const field of [
-    "available_micros",
-    "reserved_micros",
-    "spent_micros",
-    "expired_micros",
-    "platform_overrun_micros",
-  ]) {
+  for (const field of ["available_micros", "reserved_micros"]) {
     const amount = input[field];
     if (
       typeof amount !== "string" ||

package/src/packages/contracts/package.json

@@ -127,6 +127,11 @@
       "types": "./dist/database-access.d.ts",
       "import": "./dist/database-access.js"
     },
+    "./database-events": {
+      "source": "./src/database-events.ts",
+      "types": "./dist/database-events.d.ts",
+      "import": "./dist/database-events.js"
+    },
     "./functions": {
       "source": "./src/functions.ts",
       "types": "./dist/functions.d.ts",

package/src/packages/contracts/src/credit-pricing.ts

@@ -1,23 +1,28 @@
 export interface OrganizationCreditUsage {
   organization_id: string;
-  month: string;
   as_of: string;
   unit: "microcredits";
-  data: {
-    project_id: string;
-    reserved_micros: string;
-    meters: {
-      environment_id: string | null;
-      meter: string;
-      unit: string;
-      rate_card_id: string;
-      quantity: string;
-      charged_micros: string;
-      funded_micros: string;
-      platform_overrun_micros: string;
+  /** The UTC month (`YYYY-MM`) that `projects[].used_micros` counts. */
+  period: string;
+  /** The first instant of the daily lines: the start of the oldest UTC day that is reported. */
+  from: string;
+  /** What each project has used so far in `period`. */
+  projects: { project_id: string; used_micros: string }[];
+  /** The credit-log lines of the last up to 14 UTC days, grouped by day, project and meter, oldest day first. */
+  days: {
+    day: string;
+    projects: {
+      project_id: string;
+      meters: {
+        environment_id: string | null;
+        meter: string;
+        unit: string;
+        rate_card_id: string;
+        quantity: string;
+        charged_micros: string;
+      }[];
     }[];
   }[];
-  next_cursor: string | null;
 }
 
 /** A bounded read model, not a new source of accounting or billing authorization. */
@@ -38,53 +43,77 @@ export function assertOrganizationCreditUsage(
     typeof input === "string" && /^[0-7][0-9A-HJKMNP-TV-Z]{25}$/u.test(input);
   const amount = (input: unknown) =>
     typeof input === "string" && /^(0|[1-9][0-9]{0,37})$/u.test(input);
-  const report = record(value, "organization_id,month,as_of,unit,data,next_cursor");
+  const instant = (input: unknown) =>
+    typeof input === "string" &&
+    Number.isFinite(Date.parse(input)) &&
+    new Date(input).toISOString() === input;
+  const report = record(value, "organization_id,as_of,unit,period,from,projects,days");
   if (
     !identifier(report["organization_id"]) ||
-    typeof report["month"] !== "string" ||
-    !/^20[0-9]{2}-(0[1-9]|1[0-2])$/u.test(report["month"]) ||
-    typeof report["as_of"] !== "string" ||
-    !Number.isFinite(Date.parse(report["as_of"])) ||
-    new Date(report["as_of"]).toISOString() !== report["as_of"] ||
+    !instant(report["as_of"]) ||
+    !instant(report["from"]) ||
     report["unit"] !== "microcredits" ||
-    !Array.isArray(report["data"]) ||
-    report["data"].length > 20 ||
-    (report["next_cursor"] !== null && !identifier(report["next_cursor"]))
+    typeof report["period"] !== "string" ||
+    !/^20[0-9]{2}-(0[1-9]|1[0-2])$/u.test(report["period"]) ||
+    !Array.isArray(report["projects"]) ||
+    report["projects"].length > 1000 ||
+    !Array.isArray(report["days"]) ||
+    report["days"].length > 15
   )
     throw new TypeError("Invalid usage report");
   let previous = "";
-  for (const input of report["data"]) {
-    const project = record(input, "project_id,reserved_micros,meters");
+  for (const input of report["projects"]) {
+    const project = record(input, "project_id,used_micros");
     if (
       !identifier(project["project_id"]) ||
       String(project["project_id"]) <= previous ||
-      !amount(project["reserved_micros"]) ||
-      !Array.isArray(project["meters"]) ||
-      project["meters"].length > 1000
+      !amount(project["used_micros"])
     )
       throw new TypeError("Invalid usage project");
     previous = String(project["project_id"]);
-    for (const input of project["meters"]) {
-      const meter = record(
-        input,
-        "environment_id,meter,unit,rate_card_id,quantity,charged_micros,funded_micros,platform_overrun_micros",
-      );
-      if (meter["environment_id"] !== null && !identifier(meter["environment_id"]))
-        throw new TypeError("Invalid usage environment");
-      for (const key of ["meter", "unit", "rate_card_id"])
-        if (typeof meter[key] !== "string" || !/^[A-Za-z0-9_.:/-]{1,128}$/u.test(meter[key]))
-          throw new TypeError("Invalid usage meter");
-      for (const key of ["quantity", "charged_micros", "funded_micros", "platform_overrun_micros"])
-        if (!amount(meter[key])) throw new TypeError("Invalid usage amount");
+  }
+  let previousDay = "";
+  for (const input of report["days"]) {
+    const day = record(input, "day,projects");
+    if (
+      typeof day["day"] !== "string" ||
+      !/^20[0-9]{2}-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])$/u.test(day["day"]) ||
+      day["day"] <= previousDay ||
+      !Array.isArray(day["projects"]) ||
+      day["projects"].length > 1000
+    )
+      throw new TypeError("Invalid usage day");
+    previousDay = day["day"];
+    previous = "";
+    for (const projectInput of day["projects"]) {
+      const project = record(projectInput, "project_id,meters");
       if (
-        BigInt(String(meter["charged_micros"])) !==
-        BigInt(String(meter["funded_micros"])) + BigInt(String(meter["platform_overrun_micros"]))
+        !identifier(project["project_id"]) ||
+        String(project["project_id"]) <= previous ||
+        !Array.isArray(project["meters"]) ||
+        project["meters"].length > 1000
       )
-        throw new TypeError("Inconsistent usage charge");
+        throw new TypeError("Invalid usage project");
+      previous = String(project["project_id"]);
+      for (const meterInput of project["meters"]) {
+        const meter = record(
+          meterInput,
+          "environment_id,meter,unit,rate_card_id,quantity,charged_micros",
+        );
+        if (meter["environment_id"] !== null && !identifier(meter["environment_id"]))
+          throw new TypeError("Invalid usage environment");
+        for (const key of ["meter", "unit", "rate_card_id"])
+          if (typeof meter[key] !== "string" || !/^[A-Za-z0-9_.:/-]{1,128}$/u.test(meter[key]))
+            throw new TypeError("Invalid usage meter");
+        if (
+          typeof meter["quantity"] !== "string" ||
+          !/^(0|[1-9][0-9]{0,29})(\.[0-9]{1,12})?$/u.test(meter["quantity"]) ||
+          !amount(meter["charged_micros"])
+        )
+          throw new TypeError("Invalid usage amount");
+      }
     }
   }
-  if (report["next_cursor"] !== null && report["next_cursor"] !== previous)
-    throw new TypeError("Invalid usage cursor");
 }
 
 export interface PublishedCreditRateCard {
@@ -177,7 +206,7 @@ export function assertPublishedCreditRateCards(
   }
 }
 
-/** Effective feature access and credit buckets from the existing ledger. */
+/** Effective feature access and the credit account: the monthly and one-time credit and what the open reservations hold. */
 export function assertOrganizationAccount(value: unknown): void {
   if (
     !value ||
@@ -203,10 +232,9 @@ export function assertOrganizationAccount(value: unknown): void {
   for (const field of ["available_micros", "monthly_micros", "one_time_micros", "reserved_micros"])
     if (typeof v[field] !== "string" || !/^(0|[1-9][0-9]{0,18})$/u.test(v[field] as string))
       throw new TypeError("Invalid account credits");
-  if (
-    BigInt(String(v["monthly_micros"])) + BigInt(String(v["one_time_micros"])) !==
-    BigInt(String(v["available_micros"]))
-  )
+  const held = BigInt(String(v["reserved_micros"]));
+  const balance = BigInt(String(v["monthly_micros"])) + BigInt(String(v["one_time_micros"]));
+  if (BigInt(String(v["available_micros"])) !== (balance > held ? balance - held : 0n))
     throw new TypeError("Account credit buckets do not balance");
   for (const field of ["as_of", "paid_until", "next_expiry"]) {
     if (field !== "as_of" && v[field] === null) continue;