@sealant/sdk-next 0.40.0-next.770 → 0.40.0-next.772

package/dist/effect/api-client.d.ts

@@ -527,12 +527,13 @@ declare const buildControlPlaneClient: (config: SealantInternalConfig) => Effect
     readonly resourceDomains: {
         readonly ensureResourceDomain: HttpApiClient.Client.Method<import("effect/http-api/HttpApiEndpoint").HttpApiEndpoint<"ensureResourceDomain", "POST", "/v1/resource-domains/", never, never, import("effect/Schema").toCodecJson<import("effect/Schema").Struct<{
             readonly key: import("effect/Schema").String;
+            readonly budget: import("effect/Schema").optional<import("effect/Schema").Struct<Record<"cpuMillicores" | "memoryBytes" | "storageBytes", import("effect/Schema").Int>>>;
         }>>, never, import("effect/Schema").toCodecJson<import("effect/Schema").Struct<{
             readonly resourceDomainId: import("effect/Schema").String;
             readonly key: import("effect/Schema").String;
             readonly createdAt: import("effect/Schema").String;
             readonly created: import("effect/Schema").Boolean;
-        }>>, import("effect/Schema").toCodecJson<typeof import("@sealant/api-contracts").ResourceDomainForbiddenError | typeof import("@sealant/api-contracts").ResourceDomainInternalServerError>, import("@sealant/api-contracts").RequestRefusal, never>, never, never>;
+        }>>, import("effect/Schema").toCodecJson<typeof import("@sealant/api-contracts").ResourceDomainForbiddenError | typeof import("@sealant/api-contracts").ResourceDomainBudgetDiffersError | typeof import("@sealant/api-contracts").ResourceDomainInternalServerError>, import("@sealant/api-contracts").RequestRefusal, never>, never, never>;
         readonly getResourceDomain: HttpApiClient.Client.Method<import("effect/http-api/HttpApiEndpoint").HttpApiEndpoint<"getResourceDomain", "GET", "/v1/resource-domains/:resourceDomainId", import("effect/Schema").toCodecStringTree<import("effect/Schema").Struct<{
             readonly resourceDomainId: import("effect/Schema").String;
         }>>, never, never, never, import("effect/Schema").toCodecJson<import("effect/Schema").Struct<{
@@ -540,6 +541,31 @@ declare const buildControlPlaneClient: (config: SealantInternalConfig) => Effect
             readonly key: import("effect/Schema").String;
             readonly createdAt: import("effect/Schema").String;
         }>>, import("effect/Schema").toCodecJson<typeof import("@sealant/api-contracts").ResourceDomainForbiddenError | typeof import("@sealant/api-contracts").ResourceDomainNotFoundError | typeof import("@sealant/api-contracts").ResourceDomainInternalServerError>, import("@sealant/api-contracts").RequestRefusal, never>, never, never>;
+        readonly getResourceDomainBudget: HttpApiClient.Client.Method<import("effect/http-api/HttpApiEndpoint").HttpApiEndpoint<"getResourceDomainBudget", "GET", "/v1/resource-domains/:resourceDomainId/budget", import("effect/Schema").toCodecStringTree<import("effect/Schema").Struct<{
+            readonly resourceDomainId: import("effect/Schema").String;
+        }>>, never, never, never, import("effect/Schema").toCodecJson<import("effect/Schema").Struct<{
+            readonly revision: import("effect/Schema").Int;
+            readonly storageBytes: import("effect/Schema").Struct<{
+                readonly limit: import("effect/Schema").Int;
+                readonly used: import("effect/Schema").Int;
+                readonly reserved: import("effect/Schema").Int;
+                readonly warning: import("effect/Schema").Literals<readonly ["none", "80-percent", "95-percent", "full"]>;
+                readonly archived: import("effect/Schema").Int;
+                readonly protection: import("effect/Schema").Int;
+            }>;
+            readonly cpuMillicores: import("effect/Schema").Struct<{
+                readonly limit: import("effect/Schema").Int;
+                readonly used: import("effect/Schema").Int;
+                readonly reserved: import("effect/Schema").Int;
+                readonly warning: import("effect/Schema").Literals<readonly ["none", "80-percent", "95-percent", "full"]>;
+            }>;
+            readonly memoryBytes: import("effect/Schema").Struct<{
+                readonly limit: import("effect/Schema").Int;
+                readonly used: import("effect/Schema").Int;
+                readonly reserved: import("effect/Schema").Int;
+                readonly warning: import("effect/Schema").Literals<readonly ["none", "80-percent", "95-percent", "full"]>;
+            }>;
+        }>>, import("effect/Schema").toCodecJson<typeof import("@sealant/api-contracts").ResourceDomainForbiddenError | typeof import("@sealant/api-contracts").ResourceDomainNotFoundError | typeof import("@sealant/api-contracts").ResourceDomainInternalServerError>, import("@sealant/api-contracts").RequestRefusal, never>, never, never>;
         readonly getResourceDomainMember: HttpApiClient.Client.Method<import("effect/http-api/HttpApiEndpoint").HttpApiEndpoint<"getResourceDomainMember", "GET", "/v1/resource-domains/:resourceDomainId/members/:userId", import("effect/Schema").toCodecStringTree<import("effect/Schema").Struct<{
             readonly resourceDomainId: import("effect/Schema").String;
             readonly userId: import("effect/Schema").String;
@@ -585,6 +611,36 @@ declare const buildControlPlaneClient: (config: SealantInternalConfig) => Effect
             readonly version: import("effect/Schema").Int;
             readonly updatedAt: import("effect/Schema").String;
         }>>, import("effect/Schema").toCodecJson<typeof import("@sealant/api-contracts").ResourceDomainForbiddenError | typeof import("@sealant/api-contracts").ResourceDomainNotFoundError | typeof import("@sealant/api-contracts").ResourceDomainPersonNotFoundError | typeof import("@sealant/api-contracts").ResourceDomainMemberVersionConflictError | typeof import("@sealant/api-contracts").ResourceDomainInternalServerError>, import("@sealant/api-contracts").RequestRefusal, never>, never, never>;
+        readonly setResourceDomainBudget: HttpApiClient.Client.Method<import("effect/http-api/HttpApiEndpoint").HttpApiEndpoint<"setResourceDomainBudget", "PUT", "/v1/resource-domains/:resourceDomainId/budget", import("effect/Schema").toCodecStringTree<import("effect/Schema").Struct<{
+            readonly resourceDomainId: import("effect/Schema").String;
+        }>>, never, import("effect/Schema").toCodecJson<import("effect/Schema").Struct<{
+            readonly revision: import("effect/Schema").Int;
+            readonly cpuMillicores: import("effect/Schema").Int;
+            readonly memoryBytes: import("effect/Schema").Int;
+            readonly storageBytes: import("effect/Schema").Int;
+        }>>, never, import("effect/Schema").toCodecJson<import("effect/Schema").Struct<{
+            readonly revision: import("effect/Schema").Int;
+            readonly storageBytes: import("effect/Schema").Struct<{
+                readonly limit: import("effect/Schema").Int;
+                readonly used: import("effect/Schema").Int;
+                readonly reserved: import("effect/Schema").Int;
+                readonly warning: import("effect/Schema").Literals<readonly ["none", "80-percent", "95-percent", "full"]>;
+                readonly archived: import("effect/Schema").Int;
+                readonly protection: import("effect/Schema").Int;
+            }>;
+            readonly cpuMillicores: import("effect/Schema").Struct<{
+                readonly limit: import("effect/Schema").Int;
+                readonly used: import("effect/Schema").Int;
+                readonly reserved: import("effect/Schema").Int;
+                readonly warning: import("effect/Schema").Literals<readonly ["none", "80-percent", "95-percent", "full"]>;
+            }>;
+            readonly memoryBytes: import("effect/Schema").Struct<{
+                readonly limit: import("effect/Schema").Int;
+                readonly used: import("effect/Schema").Int;
+                readonly reserved: import("effect/Schema").Int;
+                readonly warning: import("effect/Schema").Literals<readonly ["none", "80-percent", "95-percent", "full"]>;
+            }>;
+        }>>, import("effect/Schema").toCodecJson<typeof import("@sealant/api-contracts").ResourceDomainForbiddenError | typeof import("@sealant/api-contracts").ResourceDomainNotFoundError | typeof import("@sealant/api-contracts").ResourceDomainBudgetRevisionConflictError | typeof import("@sealant/api-contracts").ResourceDomainInternalServerError>, import("@sealant/api-contracts").RequestRefusal, never>, never, never>;
     };
     readonly runs: {
         readonly createRun: HttpApiClient.Client.Method<import("effect/http-api/HttpApiEndpoint").HttpApiEndpoint<"createRun", "POST", "/v1/runs/", never, never, import("effect/Schema").toCodecJson<import("effect/Schema").Struct<{
@@ -2534,12 +2590,13 @@ declare const SealantApiClient_base: Context.ServiceClass<SealantApiClient, "@se
     readonly resourceDomains: {
         readonly ensureResourceDomain: HttpApiClient.Client.Method<import("effect/http-api/HttpApiEndpoint").HttpApiEndpoint<"ensureResourceDomain", "POST", "/v1/resource-domains/", never, never, import("effect/Schema").toCodecJson<import("effect/Schema").Struct<{
             readonly key: import("effect/Schema").String;
+            readonly budget: import("effect/Schema").optional<import("effect/Schema").Struct<Record<"cpuMillicores" | "memoryBytes" | "storageBytes", import("effect/Schema").Int>>>;
         }>>, never, import("effect/Schema").toCodecJson<import("effect/Schema").Struct<{
             readonly resourceDomainId: import("effect/Schema").String;
             readonly key: import("effect/Schema").String;
             readonly createdAt: import("effect/Schema").String;
             readonly created: import("effect/Schema").Boolean;
-        }>>, import("effect/Schema").toCodecJson<typeof import("@sealant/api-contracts").ResourceDomainForbiddenError | typeof import("@sealant/api-contracts").ResourceDomainInternalServerError>, import("@sealant/api-contracts").RequestRefusal, never>, never, never>;
+        }>>, import("effect/Schema").toCodecJson<typeof import("@sealant/api-contracts").ResourceDomainForbiddenError | typeof import("@sealant/api-contracts").ResourceDomainBudgetDiffersError | typeof import("@sealant/api-contracts").ResourceDomainInternalServerError>, import("@sealant/api-contracts").RequestRefusal, never>, never, never>;
         readonly getResourceDomain: HttpApiClient.Client.Method<import("effect/http-api/HttpApiEndpoint").HttpApiEndpoint<"getResourceDomain", "GET", "/v1/resource-domains/:resourceDomainId", import("effect/Schema").toCodecStringTree<import("effect/Schema").Struct<{
             readonly resourceDomainId: import("effect/Schema").String;
         }>>, never, never, never, import("effect/Schema").toCodecJson<import("effect/Schema").Struct<{
@@ -2547,6 +2604,31 @@ declare const SealantApiClient_base: Context.ServiceClass<SealantApiClient, "@se
             readonly key: import("effect/Schema").String;
             readonly createdAt: import("effect/Schema").String;
         }>>, import("effect/Schema").toCodecJson<typeof import("@sealant/api-contracts").ResourceDomainForbiddenError | typeof import("@sealant/api-contracts").ResourceDomainNotFoundError | typeof import("@sealant/api-contracts").ResourceDomainInternalServerError>, import("@sealant/api-contracts").RequestRefusal, never>, never, never>;
+        readonly getResourceDomainBudget: HttpApiClient.Client.Method<import("effect/http-api/HttpApiEndpoint").HttpApiEndpoint<"getResourceDomainBudget", "GET", "/v1/resource-domains/:resourceDomainId/budget", import("effect/Schema").toCodecStringTree<import("effect/Schema").Struct<{
+            readonly resourceDomainId: import("effect/Schema").String;
+        }>>, never, never, never, import("effect/Schema").toCodecJson<import("effect/Schema").Struct<{
+            readonly revision: import("effect/Schema").Int;
+            readonly storageBytes: import("effect/Schema").Struct<{
+                readonly limit: import("effect/Schema").Int;
+                readonly used: import("effect/Schema").Int;
+                readonly reserved: import("effect/Schema").Int;
+                readonly warning: import("effect/Schema").Literals<readonly ["none", "80-percent", "95-percent", "full"]>;
+                readonly archived: import("effect/Schema").Int;
+                readonly protection: import("effect/Schema").Int;
+            }>;
+            readonly cpuMillicores: import("effect/Schema").Struct<{
+                readonly limit: import("effect/Schema").Int;
+                readonly used: import("effect/Schema").Int;
+                readonly reserved: import("effect/Schema").Int;
+                readonly warning: import("effect/Schema").Literals<readonly ["none", "80-percent", "95-percent", "full"]>;
+            }>;
+            readonly memoryBytes: import("effect/Schema").Struct<{
+                readonly limit: import("effect/Schema").Int;
+                readonly used: import("effect/Schema").Int;
+                readonly reserved: import("effect/Schema").Int;
+                readonly warning: import("effect/Schema").Literals<readonly ["none", "80-percent", "95-percent", "full"]>;
+            }>;
+        }>>, import("effect/Schema").toCodecJson<typeof import("@sealant/api-contracts").ResourceDomainForbiddenError | typeof import("@sealant/api-contracts").ResourceDomainNotFoundError | typeof import("@sealant/api-contracts").ResourceDomainInternalServerError>, import("@sealant/api-contracts").RequestRefusal, never>, never, never>;
         readonly getResourceDomainMember: HttpApiClient.Client.Method<import("effect/http-api/HttpApiEndpoint").HttpApiEndpoint<"getResourceDomainMember", "GET", "/v1/resource-domains/:resourceDomainId/members/:userId", import("effect/Schema").toCodecStringTree<import("effect/Schema").Struct<{
             readonly resourceDomainId: import("effect/Schema").String;
             readonly userId: import("effect/Schema").String;
@@ -2592,6 +2674,36 @@ declare const SealantApiClient_base: Context.ServiceClass<SealantApiClient, "@se
             readonly version: import("effect/Schema").Int;
             readonly updatedAt: import("effect/Schema").String;
         }>>, import("effect/Schema").toCodecJson<typeof import("@sealant/api-contracts").ResourceDomainForbiddenError | typeof import("@sealant/api-contracts").ResourceDomainNotFoundError | typeof import("@sealant/api-contracts").ResourceDomainPersonNotFoundError | typeof import("@sealant/api-contracts").ResourceDomainMemberVersionConflictError | typeof import("@sealant/api-contracts").ResourceDomainInternalServerError>, import("@sealant/api-contracts").RequestRefusal, never>, never, never>;
+        readonly setResourceDomainBudget: HttpApiClient.Client.Method<import("effect/http-api/HttpApiEndpoint").HttpApiEndpoint<"setResourceDomainBudget", "PUT", "/v1/resource-domains/:resourceDomainId/budget", import("effect/Schema").toCodecStringTree<import("effect/Schema").Struct<{
+            readonly resourceDomainId: import("effect/Schema").String;
+        }>>, never, import("effect/Schema").toCodecJson<import("effect/Schema").Struct<{
+            readonly revision: import("effect/Schema").Int;
+            readonly cpuMillicores: import("effect/Schema").Int;
+            readonly memoryBytes: import("effect/Schema").Int;
+            readonly storageBytes: import("effect/Schema").Int;
+        }>>, never, import("effect/Schema").toCodecJson<import("effect/Schema").Struct<{
+            readonly revision: import("effect/Schema").Int;
+            readonly storageBytes: import("effect/Schema").Struct<{
+                readonly limit: import("effect/Schema").Int;
+                readonly used: import("effect/Schema").Int;
+                readonly reserved: import("effect/Schema").Int;
+                readonly warning: import("effect/Schema").Literals<readonly ["none", "80-percent", "95-percent", "full"]>;
+                readonly archived: import("effect/Schema").Int;
+                readonly protection: import("effect/Schema").Int;
+            }>;
+            readonly cpuMillicores: import("effect/Schema").Struct<{
+                readonly limit: import("effect/Schema").Int;
+                readonly used: import("effect/Schema").Int;
+                readonly reserved: import("effect/Schema").Int;
+                readonly warning: import("effect/Schema").Literals<readonly ["none", "80-percent", "95-percent", "full"]>;
+            }>;
+            readonly memoryBytes: import("effect/Schema").Struct<{
+                readonly limit: import("effect/Schema").Int;
+                readonly used: import("effect/Schema").Int;
+                readonly reserved: import("effect/Schema").Int;
+                readonly warning: import("effect/Schema").Literals<readonly ["none", "80-percent", "95-percent", "full"]>;
+            }>;
+        }>>, import("effect/Schema").toCodecJson<typeof import("@sealant/api-contracts").ResourceDomainForbiddenError | typeof import("@sealant/api-contracts").ResourceDomainNotFoundError | typeof import("@sealant/api-contracts").ResourceDomainBudgetRevisionConflictError | typeof import("@sealant/api-contracts").ResourceDomainInternalServerError>, import("@sealant/api-contracts").RequestRefusal, never>, never, never>;
     };
     readonly runs: {
         readonly createRun: HttpApiClient.Client.Method<import("effect/http-api/HttpApiEndpoint").HttpApiEndpoint<"createRun", "POST", "/v1/runs/", never, never, import("effect/Schema").toCodecJson<import("effect/Schema").Struct<{

package/dist/effect/operations.d.ts

@@ -1434,12 +1434,16 @@ export declare const archiveSshKeyOp: (sshKeyId: string, ownerUserId: string) =>
     readonly fingerprint: string;
     readonly createdAt: string;
 }, import("effect/http/HttpClientError").HttpClientError | import("@sealant/api-contracts").RequestRefusedError | import("effect/Schema").SchemaError | import("@sealant/api-contracts").SshKeyInternalServerError | import("@sealant/api-contracts").SshKeyNotFoundError, SealantApiClient>;
-export declare const ensureResourceDomainOp: (key: string) => Effect.Effect<{
+export declare const ensureResourceDomainOp: (key: string, budget?: {
+    readonly cpuMillicores: number;
+    readonly memoryBytes: number;
+    readonly storageBytes: number;
+} | undefined) => Effect.Effect<{
     readonly resourceDomainId: string;
     readonly key: string;
     readonly createdAt: string;
     readonly created: boolean;
-}, import("effect/http/HttpClientError").HttpClientError | import("@sealant/api-contracts").RequestRefusedError | import("@sealant/api-contracts").ResourceDomainForbiddenError | import("@sealant/api-contracts").ResourceDomainInternalServerError | import("effect/Schema").SchemaError, SealantApiClient>;
+}, import("effect/http/HttpClientError").HttpClientError | import("@sealant/api-contracts").RequestRefusedError | import("@sealant/api-contracts").ResourceDomainBudgetDiffersError | import("@sealant/api-contracts").ResourceDomainForbiddenError | import("@sealant/api-contracts").ResourceDomainInternalServerError | import("effect/Schema").SchemaError, SealantApiClient>;
 export declare const getResourceDomainOp: (resourceDomainId: string) => Effect.Effect<{
     readonly resourceDomainId: string;
     readonly key: string;
@@ -1479,3 +1483,54 @@ export declare const listResourceDomainMembersOp: (resourceDomainId: string, que
     }[];
     readonly nextCursor?: string | undefined;
 }, import("effect/http/HttpClientError").HttpClientError | import("@sealant/api-contracts").RequestRefusedError | import("@sealant/api-contracts").ResourceDomainForbiddenError | import("@sealant/api-contracts").ResourceDomainInternalServerError | import("@sealant/api-contracts").ResourceDomainNotFoundError | import("effect/Schema").SchemaError, SealantApiClient>;
+export declare const getResourceDomainBudgetOp: (resourceDomainId: string) => Effect.Effect<{
+    readonly revision: number;
+    readonly storageBytes: {
+        readonly limit: number;
+        readonly used: number;
+        readonly reserved: number;
+        readonly warning: "80-percent" | "95-percent" | "full" | "none";
+        readonly archived: number;
+        readonly protection: number;
+    };
+    readonly cpuMillicores: {
+        readonly limit: number;
+        readonly used: number;
+        readonly reserved: number;
+        readonly warning: "80-percent" | "95-percent" | "full" | "none";
+    };
+    readonly memoryBytes: {
+        readonly limit: number;
+        readonly used: number;
+        readonly reserved: number;
+        readonly warning: "80-percent" | "95-percent" | "full" | "none";
+    };
+}, import("effect/http/HttpClientError").HttpClientError | import("@sealant/api-contracts").RequestRefusedError | import("@sealant/api-contracts").ResourceDomainForbiddenError | import("@sealant/api-contracts").ResourceDomainInternalServerError | import("@sealant/api-contracts").ResourceDomainNotFoundError | import("effect/Schema").SchemaError, SealantApiClient>;
+export declare const setResourceDomainBudgetOp: (resourceDomainId: string, payload: {
+    readonly revision: number;
+    readonly cpuMillicores: number;
+    readonly memoryBytes: number;
+    readonly storageBytes: number;
+}) => Effect.Effect<{
+    readonly revision: number;
+    readonly storageBytes: {
+        readonly limit: number;
+        readonly used: number;
+        readonly reserved: number;
+        readonly warning: "80-percent" | "95-percent" | "full" | "none";
+        readonly archived: number;
+        readonly protection: number;
+    };
+    readonly cpuMillicores: {
+        readonly limit: number;
+        readonly used: number;
+        readonly reserved: number;
+        readonly warning: "80-percent" | "95-percent" | "full" | "none";
+    };
+    readonly memoryBytes: {
+        readonly limit: number;
+        readonly used: number;
+        readonly reserved: number;
+        readonly warning: "80-percent" | "95-percent" | "full" | "none";
+    };
+}, import("effect/http/HttpClientError").HttpClientError | import("@sealant/api-contracts").RequestRefusedError | import("@sealant/api-contracts").ResourceDomainBudgetRevisionConflictError | import("@sealant/api-contracts").ResourceDomainForbiddenError | import("@sealant/api-contracts").ResourceDomainInternalServerError | import("@sealant/api-contracts").ResourceDomainNotFoundError | import("effect/Schema").SchemaError, SealantApiClient>;

package/dist/effect/operations.js

@@ -87,7 +87,9 @@ export const createSshKeyOp = (payload) => Effect.flatMap(SealantApiClient, (cli
 export const listSshKeysOp = (ownerUserId) => Effect.flatMap(SealantApiClient, (client) => client.sshKeys.listSshKeys({ query: { ownerUserId } }));
 export const archiveSshKeyOp = (sshKeyId, ownerUserId) => Effect.flatMap(SealantApiClient, (client) => client.sshKeys.archiveSshKey({ params: { sshKeyId }, query: { ownerUserId } }));
 // ---- resource domains (the SDK's scopes) ----
-export const ensureResourceDomainOp = (key) => Effect.flatMap(SealantApiClient, (client) => client.resourceDomains.ensureResourceDomain({ payload: { key } }));
+export const ensureResourceDomainOp = (key, budget) => Effect.flatMap(SealantApiClient, (client) => client.resourceDomains.ensureResourceDomain({
+    payload: budget === undefined ? { key } : { key, budget },
+}));
 export const getResourceDomainOp = (resourceDomainId) => Effect.flatMap(SealantApiClient, (client) => client.resourceDomains.getResourceDomain({ params: { resourceDomainId } }));
 export const grantResourceDomainMemberOp = (resourceDomainId, userId, payload) => Effect.flatMap(SealantApiClient, (client) => client.resourceDomains.grantResourceDomainMember({
     params: { resourceDomainId, userId },
@@ -99,3 +101,5 @@ export const revokeResourceDomainMemberOp = (resourceDomainId, userId, payload)
 }));
 export const getResourceDomainMemberOp = (resourceDomainId, userId) => Effect.flatMap(SealantApiClient, (client) => client.resourceDomains.getResourceDomainMember({ params: { resourceDomainId, userId } }));
 export const listResourceDomainMembersOp = (resourceDomainId, query) => Effect.flatMap(SealantApiClient, (client) => client.resourceDomains.listResourceDomainMembers({ params: { resourceDomainId }, query }));
+export const getResourceDomainBudgetOp = (resourceDomainId) => Effect.flatMap(SealantApiClient, (client) => client.resourceDomains.getResourceDomainBudget({ params: { resourceDomainId } }));
+export const setResourceDomainBudgetOp = (resourceDomainId, payload) => Effect.flatMap(SealantApiClient, (client) => client.resourceDomains.setResourceDomainBudget({ params: { resourceDomainId }, payload }));

package/dist/index.d.ts

@@ -18,6 +18,6 @@ export { Sealant } from "./client.js";
 export { claudeCode, codex, customHarness, opencode, pi } from "./harness.js";
 export { ForwardDialError, type ForwardDialFailure, type ForwardDialReason, ForwardResetError, SealantApiError, SealantError, SealantNotImplementedError, SealantRuntimeError, } from "./errors.js";
 export type * from "./types.js";
-export type { EnsuredScope, ScopeClient, ScopeInfo, ScopeMember, ScopeMemberDecision, ScopeMemberPage, ScopeMembers, ScopesNamespace, } from "./scopes.js";
+export type { EnsuredScope, ScopeBudget, ScopeBudgetDimension, ScopeBudgetLimits, ScopeBudgets, ScopeClient, ScopeInfo, ScopeMember, ScopeMemberDecision, ScopeMemberPage, ScopeMembers, ScopesNamespace, } from "./scopes.js";
 export { findWorkspaceEnvReservedRule, findWorkspaceSecretEnvReservedRule, formatWorkspaceEnvIssue, parseWorkspaceEnv, parseWorkspaceSecretEnv, WORKSPACE_ENV_MAX_ENTRIES, WORKSPACE_ENV_MAX_NAME_LENGTH, WORKSPACE_ENV_MAX_TOTAL_BYTES, WORKSPACE_ENV_MAX_VALUE_BYTES, WORKSPACE_ENV_NAME_PATTERN, WORKSPACE_ENV_SECRET_MARKERS, } from "@sealant/api-contracts/workspace-environment";
 export type { WorkspaceEnvIssue, WorkspaceEnvParseResult, WorkspaceEnvReservedRule, } from "@sealant/api-contracts/workspace-environment";

package/dist/scopes.d.ts

@@ -1,3 +1,12 @@
+/**
+ * `sealant.scopes`: owners that are projects, not people (the control plane's resource domains).
+ *
+ * An application ensures one scope per project, by a global `<application>:<name>` key, and names
+ * the people who may reach it. A scope never holds a login or a provider credential and never runs
+ * a harness, so the client that acts as one (`actAs`) has no workspace, run, inference or
+ * credential methods at all. These calls need a service key and never use `ownerUserId`.
+ */
+import { type ResourceDomainBudgetDimension } from "@sealant/api-contracts";
 import type { SdkRuntime } from "./effect/runtime.js";
 export interface ScopeInfo {
     /** `rdm:<uuid>`. No person field of the API accepts it. */
@@ -53,16 +62,59 @@ export interface ScopeMembers {
         readonly cursor?: string;
     }): Promise<ScopeMemberPage>;
 }
+/** Ceilings on what a scope's objects may hold (CPU millicores, memory and storage bytes). */
+export type ScopeBudgetLimits = {
+    readonly [D in ResourceDomainBudgetDimension]: number;
+};
+/**
+ * `used` (confirmed to exist) and `reserved` (admitted, not yet confirmed) both count against
+ * `limit`; `warning` is the highest share of it they reach.
+ */
+export interface ScopeBudgetDimension {
+    readonly limit: number;
+    readonly used: number;
+    readonly reserved: number;
+    readonly warning: "none" | "80-percent" | "95-percent" | "full";
+}
+/** Storage is one allowance, archived volumes and protection included; nothing is deleted to free it. */
+export type ScopeBudget = {
+    /** Name it to change the budget: a change made since refuses yours. */
+    readonly revision: number;
+} & {
+    readonly [D in ResourceDomainBudgetDimension]: ScopeBudgetDimension;
+} & {
+    readonly storageBytes: {
+        readonly archived: number;
+        readonly protection: number;
+    };
+};
+export interface ScopeBudgets {
+    get(): Promise<ScopeBudget>;
+    /**
+     * Replace the budget at the `revision` you read. A change since rejects (409,
+     * `ResourceDomainBudgetRevisionConflictError`). It answers the budget it wrote, and changes
+     * nothing the scope holds.
+     */
+    set(change: ScopeBudgetLimits & {
+        readonly revision: number;
+    }): Promise<ScopeBudget>;
+}
 /** A client acting as one scope. It has no method that could reach a credential or a harness. */
 export interface ScopeClient {
     readonly id: string;
     get(): Promise<ScopeInfo>;
     readonly members: ScopeMembers;
+    readonly budget: ScopeBudgets;
 }
 export interface ScopesNamespace {
-    /** The scope with this key, created on the first call; later and concurrent calls answer it. */
+    /**
+     * The scope with this key, created on the first call (with `budget`, or zero); later and
+     * concurrent calls answer it. Naming another budget rejects (409,
+     * `ResourceDomainBudgetDiffersError`, carrying the scope's id and its budget's revision).
+     */
     ensure(options: {
         readonly key: string;
+        readonly budget?: ScopeBudgetLimits;
     }): Promise<EnsuredScope>;
     get(scopeId: string): Promise<ScopeInfo>;
     /** A client for this scope alone, and the only way to its members. Nothing is checked until its first call. */

package/dist/scopes.js

@@ -1,4 +1,14 @@
-import { ensureResourceDomainOp, getResourceDomainMemberOp, getResourceDomainOp, grantResourceDomainMemberOp, listResourceDomainMembersOp, revokeResourceDomainMemberOp, } from "./effect/operations.js";
+/**
+ * `sealant.scopes`: owners that are projects, not people (the control plane's resource domains).
+ *
+ * An application ensures one scope per project, by a global `<application>:<name>` key, and names
+ * the people who may reach it. A scope never holds a login or a provider credential and never runs
+ * a harness, so the client that acts as one (`actAs`) has no workspace, run, inference or
+ * credential methods at all. These calls need a service key and never use `ownerUserId`.
+ */
+import { RESOURCE_DOMAIN_BUDGET_DIMENSIONS, } from "@sealant/api-contracts";
+import * as Rec from "effect/Record";
+import { ensureResourceDomainOp, getResourceDomainBudgetOp, getResourceDomainMemberOp, getResourceDomainOp, grantResourceDomainMemberOp, listResourceDomainMembersOp, revokeResourceDomainMemberOp, setResourceDomainBudgetOp, } from "./effect/operations.js";
 const toScope = (wire) => ({
     id: wire.resourceDomainId,
     key: wire.key,
@@ -7,8 +17,8 @@ const toScope = (wire) => ({
 export const makeScopes = (runtime) => {
     const get = async (scopeId) => toScope(await runtime.run(getResourceDomainOp(scopeId)));
     return {
-        ensure: async ({ key }) => {
-            const wire = await runtime.run(ensureResourceDomainOp(key));
+        ensure: async ({ key, budget }) => {
+            const wire = await runtime.run(ensureResourceDomainOp(key, budget));
             return { ...toScope(wire), created: wire.created };
         },
         get,
@@ -26,6 +36,13 @@ export const makeScopes = (runtime) => {
                         : { items: page.items, nextCursor: page.nextCursor };
                 },
             },
+            budget: {
+                get: () => runtime.run(getResourceDomainBudgetOp(scopeId)),
+                set: (change) => runtime.run(setResourceDomainBudgetOp(scopeId, {
+                    ...Rec.map(RESOURCE_DOMAIN_BUDGET_DIMENSIONS, (_, dimension) => change[dimension]),
+                    revision: change.revision,
+                })),
+            },
         }),
     };
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sealant/sdk-next",
-  "version": "0.40.0-next.770",
+  "version": "0.40.0-next.772",
   "description": "The fluent public SDK for Sealant — create a workspace, run a harness, replay the record.",
   "license": "Apache-2.0",
   "repository": {
@@ -26,12 +26,12 @@
     "node": ">=20"
   },
   "dependencies": {
-    "@sealant/api-contracts": "npm:@sealant/api-contracts-next@0.40.0-next.770"
+    "@sealant/api-contracts": "npm:@sealant/api-contracts-next@0.40.0-next.772"
   },
   "peerDependencies": {
     "effect": "^4.0.5"
   },
-  "gitHead": "1e8b4f1153f5107504649c863c305cd31f424d58",
+  "gitHead": "722ef7c7d08581db5c9c4de770d5630329063a97",
   "publishConfig": {
     "access": "public"
   }