@opengeni/contracts 3.2.2 → 3.4.0

package/dist/interaction.d.ts

@@ -5681,12 +5681,282 @@ export declare const BrowserSessionMutationResponse: z.ZodObject<{
         dispatchedAt: z.ZodNullable<z.ZodString>;
         settledAt: z.ZodNullable<z.ZodString>;
     }, z.core.$strict>;
+    initialView: z.ZodOptional<z.ZodObject<{
+        targets: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            browserSessionId: z.ZodString;
+            controllerGeneration: z.ZodString;
+            targetGeneration: z.ZodString;
+            documentGeneration: z.ZodNullable<z.ZodString>;
+            kind: z.ZodEnum<{
+                background_page: "background_page";
+                page: "page";
+                popup: "popup";
+                worker: "worker";
+            }>;
+            title: z.ZodString;
+            url: z.ZodString;
+            selected: z.ZodBoolean;
+            attached: z.ZodBoolean;
+            createdAt: z.ZodString;
+        }, z.core.$strict>>;
+        observation: z.ZodObject<{
+            protocolVersion: z.ZodLiteral<1>;
+            observationId: z.ZodString;
+            browserSessionId: z.ZodString;
+            target: z.ZodObject<{
+                id: z.ZodString;
+                browserSessionId: z.ZodString;
+                controllerGeneration: z.ZodString;
+                targetGeneration: z.ZodString;
+                documentGeneration: z.ZodNullable<z.ZodString>;
+                kind: z.ZodEnum<{
+                    background_page: "background_page";
+                    page: "page";
+                    popup: "popup";
+                    worker: "worker";
+                }>;
+                title: z.ZodString;
+                url: z.ZodString;
+                selected: z.ZodBoolean;
+                attached: z.ZodBoolean;
+                createdAt: z.ZodString;
+            }, z.core.$strict>;
+            frameId: z.ZodNullable<z.ZodString>;
+            semantic: z.ZodNullable<z.ZodUnion<readonly [z.ZodObject<{
+                kind: z.ZodLiteral<"snapshot">;
+                roots: z.ZodArray<z.ZodType<InteractionSemanticNodeValue, unknown, z.core.$ZodTypeInternals<InteractionSemanticNodeValue, unknown>>>;
+                nodeCount: z.ZodNumber;
+            }, z.core.$strict>, z.ZodObject<{
+                kind: z.ZodLiteral<"diff">;
+                baseObservationId: z.ZodString;
+                removedRefs: z.ZodArray<z.ZodString>;
+                changed: z.ZodArray<z.ZodType<InteractionSemanticNodeValue, unknown, z.core.$ZodTypeInternals<InteractionSemanticNodeValue, unknown>>>;
+            }, z.core.$strict>]>>;
+            screenshot: z.ZodNullable<z.ZodObject<{
+                available: z.ZodLiteral<true>;
+                artifactId: z.ZodString;
+                kind: z.ZodEnum<{
+                    assistant_completion: "assistant_completion";
+                    browser_screenshot: "browser_screenshot";
+                    computer_screenshot: "computer_screenshot";
+                    event_media: "event_media";
+                    file: "file";
+                    generated_image: "generated_image";
+                    generated_video: "generated_video";
+                    internal_update: "internal_update";
+                    tool_result: "tool_result";
+                }>;
+                contentType: z.ZodString;
+                originalBytes: z.ZodNumber;
+                sha256: z.ZodString;
+                retainedAt: z.ZodString;
+                dimensions: z.ZodOptional<z.ZodObject<{
+                    width: z.ZodNumber;
+                    height: z.ZodNumber;
+                }, z.core.$strict>>;
+                retention: z.ZodUnion<readonly [z.ZodObject<{
+                    policy: z.ZodLiteral<"workspace_file">;
+                    expiresAt: z.ZodNull;
+                }, z.core.$strict>, z.ZodObject<{
+                    policy: z.ZodLiteral<"session_screenshot">;
+                    expiresAt: z.ZodString;
+                }, z.core.$strict>]>;
+                retrieval: z.ZodObject<{
+                    method: z.ZodLiteral<"GET">;
+                    path: z.ZodString;
+                    acceptRanges: z.ZodLiteral<"bytes">;
+                    maxRangeBytes: z.ZodNumber;
+                }, z.core.$strict>;
+            }, z.core.$strict>>;
+            viewport: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                width: z.ZodNumber;
+                height: z.ZodNumber;
+                visualWidth: z.ZodNumber;
+                visualHeight: z.ZodNumber;
+                deviceScaleFactor: z.ZodNumber;
+                maxTouchPoints: z.ZodNumber;
+            }, z.core.$strict>>>;
+            focusedRef: z.ZodNullable<z.ZodString>;
+            changedRegions: z.ZodArray<z.ZodObject<{
+                x: z.ZodNumber;
+                y: z.ZodNumber;
+                width: z.ZodNumber;
+                height: z.ZodNumber;
+            }, z.core.$strict>>;
+            diagnostics: z.ZodObject<{
+                consoleErrorCount: z.ZodNumber;
+                failedRequestCount: z.ZodNumber;
+                downloadCount: z.ZodNumber;
+                pageErrorCount: z.ZodNumber;
+            }, z.core.$strict>;
+            dialog: z.ZodNullable<z.ZodObject<{
+                type: z.ZodEnum<{
+                    alert: "alert";
+                    beforeunload: "beforeunload";
+                    confirm: "confirm";
+                    prompt: "prompt";
+                }>;
+                message: z.ZodString;
+                defaultPrompt: z.ZodString;
+                openedAt: z.ZodString;
+            }, z.core.$strict>>;
+            observedAt: z.ZodString;
+        }, z.core.$strict>;
+    }, z.core.$strict>>;
 }, z.core.$strict>;
 export type BrowserSessionMutationResponse = z.infer<typeof BrowserSessionMutationResponse>;
 export declare const BrowserSessionLifecycleRequest: z.ZodObject<{
     operationId: z.ZodString;
 }, z.core.$strict>;
 export type BrowserSessionLifecycleRequest = z.infer<typeof BrowserSessionLifecycleRequest>;
+/** Why a preserved working copy cannot be adopted as it is. */
+export declare const BrowserWorkingCopyRefusal: z.ZodEnum<{
+    adoption_not_needed: "adoption_not_needed";
+    adoption_unresolved: "adoption_unresolved";
+    authority_changed: "authority_changed";
+    browser_running: "browser_running";
+    process_state_unknown: "process_state_unknown";
+    receipt_not_adoptable: "receipt_not_adoptable";
+    unsupported_browser: "unsupported_browser";
+    unsupported_platform: "unsupported_platform";
+    working_copy_invalid: "working_copy_invalid";
+}>;
+export type BrowserWorkingCopyRefusal = z.infer<typeof BrowserWorkingCopyRefusal>;
+/** One adoption of a copied working directory, as its controller recorded it.
+ * `adopted` is the only phase in which the browser runs from the copy; the
+ * other terminal phases left the browser's own directory untouched or
+ * restored, and every directory kept is listed for separate cleanup. */
+export declare const BrowserWorkingCopyAdoption: z.ZodObject<{
+    operationId: z.ZodString;
+    browserSessionId: z.ZodString;
+    controllerGeneration: z.ZodString;
+    manifestDigest: z.ZodString;
+    phase: z.ZodEnum<{
+        adopted: "adopted";
+        collision: "collision";
+        copied: "copied";
+        failed: "failed";
+        intent: "intent";
+        interrupted: "interrupted";
+        receipt: "receipt";
+        reverted: "reverted";
+        reverting: "reverting";
+        source_preserved: "source_preserved";
+    }>;
+    failureCode: z.ZodNullable<z.ZodString>;
+    retainedDirectories: z.ZodArray<z.ZodString>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+}, z.core.$strict>;
+export type BrowserWorkingCopyAdoption = z.infer<typeof BrowserWorkingCopyAdoption>;
+/** Evidence about a browser's preserved working copy after its controller
+ * lost it, for example after the machine's disk was restored from a copy.
+ * Machine evidence (receipt, profile identity, process proof, exact byte
+ * digest) is kept separate from freshness, which is never proven: whoever
+ * adopts the copy selects it as the browser's state. */
+export declare const BrowserWorkingCopyInspection: z.ZodObject<{
+    browserSessionId: z.ZodString;
+    controllerGeneration: z.ZodString;
+    adoptable: z.ZodBoolean;
+    refusal: z.ZodNullable<z.ZodEnum<{
+        adoption_not_needed: "adoption_not_needed";
+        adoption_unresolved: "adoption_unresolved";
+        authority_changed: "authority_changed";
+        browser_running: "browser_running";
+        process_state_unknown: "process_state_unknown";
+        receipt_not_adoptable: "receipt_not_adoptable";
+        unsupported_browser: "unsupported_browser";
+        unsupported_platform: "unsupported_platform";
+        working_copy_invalid: "working_copy_invalid";
+    }>>;
+    explanation: z.ZodString;
+    manifest: z.ZodNullable<z.ZodObject<{
+        digest: z.ZodString;
+        entries: z.ZodNumber;
+        bytes: z.ZodNumber;
+        excluded: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    platformSupported: z.ZodBoolean;
+    profileIdentityMatches: z.ZodBoolean;
+    profileInUse: z.ZodNullable<z.ZodBoolean>;
+    receipt: z.ZodNullable<z.ZodObject<{
+        operationId: z.ZodString;
+        intent: z.ZodEnum<{
+            adopt: "adopt";
+            launch: "launch";
+            retire: "retire";
+            suspend: "suspend";
+        }>;
+        state: z.ZodString;
+        directoryLaunchAllowed: z.ZodBoolean;
+        authorityMatches: z.ZodBoolean;
+        launchedFromCheckpoint: z.ZodBoolean;
+        adoption: z.ZodNullable<z.ZodObject<{
+            operationId: z.ZodString;
+            manifestDigest: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    freshness: z.ZodObject<{
+        status: z.ZodLiteral<"unknown">;
+        latestCheckpointAt: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>;
+    activeAdoption: z.ZodNullable<z.ZodObject<{
+        operationId: z.ZodString;
+        browserSessionId: z.ZodString;
+        controllerGeneration: z.ZodString;
+        manifestDigest: z.ZodString;
+        phase: z.ZodEnum<{
+            adopted: "adopted";
+            collision: "collision";
+            copied: "copied";
+            failed: "failed";
+            intent: "intent";
+            interrupted: "interrupted";
+            receipt: "receipt";
+            reverted: "reverted";
+            reverting: "reverting";
+            source_preserved: "source_preserved";
+        }>;
+        failureCode: z.ZodNullable<z.ZodString>;
+        retainedDirectories: z.ZodArray<z.ZodString>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type BrowserWorkingCopyInspection = z.infer<typeof BrowserWorkingCopyInspection>;
+export declare const BrowserWorkingCopyAdoptionRequest: z.ZodObject<{
+    operationId: z.ZodString;
+    manifestDigest: z.ZodString;
+}, z.core.$strict>;
+export type BrowserWorkingCopyAdoptionRequest = z.infer<typeof BrowserWorkingCopyAdoptionRequest>;
+export declare const BrowserWorkingCopyAdoptionResponse: z.ZodObject<{
+    inFlight: z.ZodBoolean;
+    adoption: z.ZodNullable<z.ZodObject<{
+        operationId: z.ZodString;
+        browserSessionId: z.ZodString;
+        controllerGeneration: z.ZodString;
+        manifestDigest: z.ZodString;
+        phase: z.ZodEnum<{
+            adopted: "adopted";
+            collision: "collision";
+            copied: "copied";
+            failed: "failed";
+            intent: "intent";
+            interrupted: "interrupted";
+            receipt: "receipt";
+            reverted: "reverted";
+            reverting: "reverting";
+            source_preserved: "source_preserved";
+        }>;
+        failureCode: z.ZodNullable<z.ZodString>;
+        retainedDirectories: z.ZodArray<z.ZodString>;
+        createdAt: z.ZodString;
+        updatedAt: z.ZodString;
+    }, z.core.$strict>>;
+    explanation: z.ZodString;
+}, z.core.$strict>;
+export type BrowserWorkingCopyAdoptionResponse = z.infer<typeof BrowserWorkingCopyAdoptionResponse>;
 export declare const BrowserOpenTargetRequest: z.ZodObject<{
     url: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;

package/dist/personal-github.js

@@ -1,6 +1,6 @@
 import {
   ConnectionMetadata
-} from "./chunk-B2G6NXLZ.js";
+} from "./chunk-J6VQQPIL.js";
 import "./chunk-EFZYKUE2.js";
 import "./chunk-Z7WEVGCL.js";
 import "./chunk-LZ2LAHIX.js";

package/dist/subscription-plans.d.ts

@@ -0,0 +1,35 @@
+import { z } from "zod";
+/** Operator-managed catalog; monetary amounts are USD micro-units. */
+export declare const SubscriptionPlan: z.ZodObject<{
+    key: z.ZodString;
+    label: z.ZodString;
+    stripePriceId: z.ZodNullable<z.ZodString>;
+    monthlyPriceMicros: z.ZodNullable<z.ZodNumber>;
+    monthlyCreditMicros: z.ZodNumber;
+    seatLimit: z.ZodNullable<z.ZodNumber>;
+    freeCredit: z.ZodBoolean;
+}, z.core.$strict>;
+export type SubscriptionPlan = z.infer<typeof SubscriptionPlan>;
+export declare const SubscriptionPlanCatalog: z.ZodArray<z.ZodObject<{
+    key: z.ZodString;
+    label: z.ZodString;
+    stripePriceId: z.ZodNullable<z.ZodString>;
+    monthlyPriceMicros: z.ZodNullable<z.ZodNumber>;
+    monthlyCreditMicros: z.ZodNumber;
+    seatLimit: z.ZodNullable<z.ZodNumber>;
+    freeCredit: z.ZodBoolean;
+}, z.core.$strict>>;
+export type SubscriptionPlanCatalog = z.infer<typeof SubscriptionPlanCatalog>;
+export declare const BillingPlanBalance: z.ZodObject<{
+    key: z.ZodString;
+    label: z.ZodString;
+    status: z.ZodString;
+    creditGrantedMicros: z.ZodNumber;
+    creditRemainingMicros: z.ZodNumber;
+    creditPendingExpiryMicros: z.ZodOptional<z.ZodNumber>;
+    periodResetAt: z.ZodNullable<z.ZodString>;
+    seatLimit: z.ZodNullable<z.ZodNumber>;
+    seatsUsed: z.ZodNumber;
+    cancelAtPeriodEnd: z.ZodBoolean;
+}, z.core.$strip>;
+export type BillingPlanBalance = z.infer<typeof BillingPlanBalance>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@opengeni/contracts",
-  "version": "3.2.2",
+  "version": "3.4.0",
   "description": "Shared zod schemas and wire-contract types for the Opengeni API.",
   "license": "Apache-2.0",
   "repository": {

package/src/billing-subscriptions.ts

@@ -0,0 +1,47 @@
+import { z } from "zod";
+import { BillingPlanBalance, SubscriptionPlan } from "./subscription-plans";
+
+export const BillingSubscriptionCatalog = z.object({
+  accountId: z.string().uuid(),
+  revision: z.number().int().positive(),
+  plans: z.array(SubscriptionPlan.extend({ selfService: z.boolean() })),
+  plan: BillingPlanBalance.nullable(),
+});
+export type BillingSubscriptionCatalog = z.infer<typeof BillingSubscriptionCatalog>;
+
+export const CreateSubscriptionCheckoutRequest = z.strictObject({
+  accountId: z.string().uuid().optional(),
+  planKey: z.string().min(1).max(40),
+  /** Stable across retries of the same action; use a fresh UUID for a new action. */
+  idempotencyKey: z.string().uuid(),
+  successUrl: z.string().url().optional(),
+  cancelUrl: z.string().url().optional(),
+});
+export type CreateSubscriptionCheckoutRequest = z.infer<typeof CreateSubscriptionCheckoutRequest>;
+
+export const CreateSubscriptionCheckoutResponse = z.object({
+  checkoutSessionId: z.string(),
+  url: z.string().url(),
+});
+export type CreateSubscriptionCheckoutResponse = z.infer<typeof CreateSubscriptionCheckoutResponse>;
+
+export const ChangeBillingSubscriptionRequest = z.strictObject({
+  accountId: z.string().uuid().optional(),
+  planKey: z.string().min(1).max(40),
+  idempotencyKey: z.string().uuid(),
+});
+export type ChangeBillingSubscriptionRequest = z.infer<typeof ChangeBillingSubscriptionRequest>;
+
+export const CancelBillingSubscriptionRequest = z.strictObject({
+  accountId: z.string().uuid().optional(),
+  idempotencyKey: z.string().uuid(),
+});
+export type CancelBillingSubscriptionRequest = z.infer<typeof CancelBillingSubscriptionRequest>;
+
+export const BillingSubscriptionChange = z.object({
+  subscriptionId: z.string(),
+  planKey: z.string(),
+  effectiveAt: z.string().datetime(),
+  cancelAtPeriodEnd: z.boolean(),
+});
+export type BillingSubscriptionChange = z.infer<typeof BillingSubscriptionChange>;

package/src/index.ts

@@ -5864,6 +5864,21 @@ export const PromotionalCreditBalance = /* @__PURE__ */ defineSchema(() =>
 );
 export type PromotionalCreditBalance = z.infer<typeof PromotionalCreditBalance>;
 
+export {
+  SubscriptionPlan,
+  SubscriptionPlanCatalog,
+  BillingPlanBalance,
+} from "./subscription-plans";
+export {
+  BillingSubscriptionCatalog,
+  CreateSubscriptionCheckoutRequest,
+  CreateSubscriptionCheckoutResponse,
+  ChangeBillingSubscriptionRequest,
+  CancelBillingSubscriptionRequest,
+  BillingSubscriptionChange,
+} from "./billing-subscriptions";
+import { BillingPlanBalance } from "./subscription-plans";
+
 export const BillingBalance = /* @__PURE__ */ defineSchema(() =>
   z.object({
     accountId: z.string().uuid(),
@@ -5873,6 +5888,8 @@ export const BillingBalance = /* @__PURE__ */ defineSchema(() =>
     /** General credits, including unrestricted legacy grants. May be negative after use. */
     generalBalanceMicros: z.number().int().optional(),
     promotionalCredits: z.array(PromotionalCreditBalance).optional(),
+    /** Absent/null until an operator or subscription worker activates this organization. */
+    plan: BillingPlanBalance.nullable().optional(),
   }),
 );
 export type BillingBalance = z.infer<typeof BillingBalance>;
@@ -15798,6 +15815,8 @@ export const SessionListResponse = /* @__PURE__ */ defineSkillContractSchema(()
     needsYouOnly: z.literal(true).optional(),
     /** Explicit receipt for the read-only (archived idle session) filter. */
     contentArchivedOnly: z.literal(true).optional(),
+    /** Explicit receipt for the started-or-messaged-by-you filter. */
+    mineOnly: z.literal(true).optional(),
     totals: SessionListTotals.optional(),
     /** Effective server ordering; name uses ASCII-space trim, ASCII case fold,
      * UTF-8 byte order, then id ASC. Date keys and their id ties use DESC. */

package/src/insights-usage.ts

@@ -15,6 +15,44 @@ export const InsightsUsageRange = /* @__PURE__ */ defineSchema(() =>
 );
 export type InsightsUsageRange = z.infer<typeof InsightsUsageRange>;
 
+/** Aggregate Site accounting only: no viewer, session, turn or prompt identities. */
+export const InsightsSiteUsageQuery = /* @__PURE__ */ defineSchema(() =>
+  z
+    .object({ range: z.enum(["today", "week", "month", "30d", "90d", "ytd"]).default("month") })
+    .strict(),
+);
+export type InsightsSiteUsageQuery = z.infer<typeof InsightsSiteUsageQuery>;
+export const InsightsSiteUsageRow = /* @__PURE__ */ defineSchema(() =>
+  z
+    .object({
+      siteId: Identifier.nullable(),
+      title: z.string(),
+      kind: z.enum(["site", "restricted", "other"]),
+      calls: SafeCount,
+      pricedCalls: SafeCount,
+      /** Settled negative model-usage ledger entries, not a provider price. */
+      chargedMicros: SafeCount,
+      /** Recorded API-equivalent estimates across all payment paths. */
+      apiEquivalentMicros: SafeCount,
+      subscriptionApiEquivalentMicros: SafeCount,
+      ownKeyApiEquivalentMicros: SafeCount,
+    })
+    .strict(),
+);
+export type InsightsSiteUsageRow = z.infer<typeof InsightsSiteUsageRow>;
+export const InsightsSiteUsageResponse = /* @__PURE__ */ defineSchema(() =>
+  z
+    .object({
+      workspaceId: Identifier,
+      range: InsightsSiteUsageQuery.shape.range,
+      windowStart: UtcDateTime,
+      windowEnd: UtcDateTime,
+      rows: z.array(InsightsSiteUsageRow).max(201),
+    })
+    .strict(),
+);
+export type InsightsSiteUsageResponse = z.infer<typeof InsightsSiteUsageResponse>;
+
 export const InsightsUsageGroupBy = /* @__PURE__ */ defineSchema(() =>
   z.enum([
     "model",

package/src/interaction.ts

@@ -2806,6 +2806,17 @@ export const BrowserSessionMutationResponse = /* @__PURE__ */ defineSchema(() =>
     .object({
       session: BrowserSession,
       operation: InteractionLifecycleOperationReceipt,
+      /** Set only by a create that launched the browser in this request: the
+       * tabs and the opened tab's observation exactly as the controller
+       * produced them, so a caller does not need two more reads. A replayed
+       * or failed create omits it; read the targets and observe instead. */
+      initialView: z
+        .object({
+          targets: z.array(BrowserTarget).max(10_000),
+          observation: BrowserObservation,
+        })
+        .strict()
+        .optional(),
     })
     .strict(),
 );
@@ -2820,6 +2831,137 @@ export const BrowserSessionLifecycleRequest = /* @__PURE__ */ defineSchema(() =>
 );
 export type BrowserSessionLifecycleRequest = z.infer<typeof BrowserSessionLifecycleRequest>;
 
+/** Why a preserved working copy cannot be adopted as it is. */
+export const BrowserWorkingCopyRefusal = /* @__PURE__ */ defineSchema(() =>
+  z.enum([
+    "unsupported_platform",
+    "unsupported_browser",
+    "browser_running",
+    "working_copy_invalid",
+    "receipt_not_adoptable",
+    "authority_changed",
+    "process_state_unknown",
+    "adoption_not_needed",
+    "adoption_unresolved",
+  ]),
+);
+export type BrowserWorkingCopyRefusal = z.infer<typeof BrowserWorkingCopyRefusal>;
+
+/** One adoption of a copied working directory, as its controller recorded it.
+ * `adopted` is the only phase in which the browser runs from the copy; the
+ * other terminal phases left the browser's own directory untouched or
+ * restored, and every directory kept is listed for separate cleanup. */
+export const BrowserWorkingCopyAdoption = /* @__PURE__ */ defineSchema(() =>
+  z
+    .object({
+      operationId: z.string().uuid(),
+      browserSessionId: z.string().uuid(),
+      controllerGeneration: opaqueGeneration,
+      manifestDigest: sha256Hex,
+      phase: z.enum([
+        "intent",
+        "copied",
+        "receipt",
+        "source_preserved",
+        "adopted",
+        "interrupted",
+        "failed",
+        "collision",
+        "reverting",
+        "reverted",
+      ]),
+      failureCode: z.string().min(1).max(64).nullable(),
+      retainedDirectories: z.array(z.string().min(1).max(256)).max(64),
+      createdAt: z.string().datetime({ offset: true }),
+      updatedAt: z.string().datetime({ offset: true }),
+    })
+    .strict(),
+);
+export type BrowserWorkingCopyAdoption = z.infer<typeof BrowserWorkingCopyAdoption>;
+
+/** Evidence about a browser's preserved working copy after its controller
+ * lost it, for example after the machine's disk was restored from a copy.
+ * Machine evidence (receipt, profile identity, process proof, exact byte
+ * digest) is kept separate from freshness, which is never proven: whoever
+ * adopts the copy selects it as the browser's state. */
+export const BrowserWorkingCopyInspection = /* @__PURE__ */ defineSchema(() =>
+  z
+    .object({
+      browserSessionId: z.string().uuid(),
+      controllerGeneration: opaqueGeneration,
+      adoptable: z.boolean(),
+      refusal: BrowserWorkingCopyRefusal.nullable(),
+      /** Plain explanation of the state and the next action. */
+      explanation: z.string().min(1).max(2_048),
+      /** Exact digest of the bytes an adoption would take; pass it to adopt. */
+      manifest: z
+        .object({
+          digest: sha256Hex,
+          entries: z.number().int().nonnegative(),
+          bytes: z.number().int().nonnegative(),
+          /** Controller-owned derived entries left out of the copy (journal
+           * shared-memory indexes and the per-launch launcher folder). */
+          excluded: z.array(z.string().min(1).max(256)).max(16),
+        })
+        .strict()
+        .nullable(),
+      platformSupported: z.boolean(),
+      profileIdentityMatches: z.boolean(),
+      profileInUse: z.boolean().nullable(),
+      receipt: z
+        .object({
+          operationId: z.string().uuid(),
+          intent: z.enum(["launch", "suspend", "retire", "adopt"]),
+          state: z.string().min(1).max(64),
+          directoryLaunchAllowed: z.boolean(),
+          authorityMatches: z.boolean(),
+          launchedFromCheckpoint: z.boolean(),
+          adoption: z
+            .object({ operationId: z.string().uuid(), manifestDigest: sha256Hex })
+            .strict()
+            .nullable(),
+        })
+        .strict()
+        .nullable(),
+      freshness: z
+        .object({
+          /** How recent the copy's contents are is not machine-proven. */
+          status: z.literal("unknown"),
+          /** When the browser's latest saved checkpoint was taken, if any. */
+          latestCheckpointAt: z.string().datetime({ offset: true }).nullable(),
+        })
+        .strict(),
+      activeAdoption: BrowserWorkingCopyAdoption.nullable(),
+    })
+    .strict(),
+);
+export type BrowserWorkingCopyInspection = z.infer<typeof BrowserWorkingCopyInspection>;
+
+export const BrowserWorkingCopyAdoptionRequest = /* @__PURE__ */ defineSchema(() =>
+  z
+    .object({
+      operationId: z.string().uuid(),
+      /** The manifest digest from an inspection of the exact bytes to adopt. */
+      manifestDigest: sha256Hex,
+    })
+    .strict(),
+);
+export type BrowserWorkingCopyAdoptionRequest = z.infer<typeof BrowserWorkingCopyAdoptionRequest>;
+
+export const BrowserWorkingCopyAdoptionResponse = /* @__PURE__ */ defineSchema(() =>
+  z
+    .object({
+      /** True while the controller is still running this adoption. */
+      inFlight: z.boolean(),
+      /** Null when the controller has no record of the operation, which
+       * proves it changed nothing there. */
+      adoption: BrowserWorkingCopyAdoption.nullable(),
+      explanation: z.string().min(1).max(2_048),
+    })
+    .strict(),
+);
+export type BrowserWorkingCopyAdoptionResponse = z.infer<typeof BrowserWorkingCopyAdoptionResponse>;
+
 export const BrowserOpenTargetRequest = /* @__PURE__ */ defineSchema(() =>
   z
     .object({

package/src/subscription-plans.ts

@@ -0,0 +1,43 @@
+import { z } from "zod";
+
+/** Operator-managed catalog; monetary amounts are USD micro-units. */
+export const SubscriptionPlan = z.strictObject({
+  key: z.string().regex(/^[a-z][a-z0-9_-]{0,39}$/),
+  label: z.string().trim().min(1).max(120),
+  stripePriceId: z.string().trim().min(1).max(200).nullable(),
+  monthlyPriceMicros: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER).nullable(),
+  monthlyCreditMicros: z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER),
+  seatLimit: z.number().int().positive().max(1_000_000).nullable(),
+  freeCredit: z.boolean(),
+});
+export type SubscriptionPlan = z.infer<typeof SubscriptionPlan>;
+
+export const SubscriptionPlanCatalog = z
+  .array(SubscriptionPlan)
+  .min(1)
+  .max(100)
+  .superRefine((plans, context) => {
+    if (new Set(plans.map((plan) => plan.key)).size !== plans.length) {
+      context.addIssue({ code: "custom", message: "Plan keys must be unique" });
+    }
+    const prices = plans.flatMap((plan) => (plan.stripePriceId ? [plan.stripePriceId] : []));
+    if (new Set(prices).size !== prices.length) {
+      context.addIssue({ code: "custom", message: "Stripe price IDs must be unique" });
+    }
+  });
+export type SubscriptionPlanCatalog = z.infer<typeof SubscriptionPlanCatalog>;
+
+export const BillingPlanBalance = z.object({
+  key: z.string(),
+  label: z.string(),
+  status: z.string(),
+  creditGrantedMicros: z.number().int().nonnegative(),
+  creditRemainingMicros: z.number().int().nonnegative(),
+  /** Already unavailable, but not yet removed from the physical ledger. */
+  creditPendingExpiryMicros: z.number().int().nonnegative().optional(),
+  periodResetAt: z.string().nullable(),
+  seatLimit: z.number().int().positive().nullable(),
+  seatsUsed: z.number().int().nonnegative(),
+  cancelAtPeriodEnd: z.boolean(),
+});
+export type BillingPlanBalance = z.infer<typeof BillingPlanBalance>;