@sylphx/cli 0.7.0 → 0.7.2

package/dist/main.js

@@ -15,7 +15,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@sylphx/cli",
-      version: "0.7.0",
+      version: "0.7.2",
       description: "Sylphx Platform CLI \u2014 deploy and manage your applications from the terminal. 63 commands across deployment, logs, env vars, domains, databases, storage, monitoring, self-service (user), admin (users/quotas/audit/invitations/jwt-keys/project-migrate), and more.",
       type: "module",
       homepage: "https://sylphx.com",
@@ -71,7 +71,7 @@ var init_package = __esm({
         "@effect/cli": "0.75.1",
         "@effect/platform": "0.96.0",
         "@effect/platform-bun": "0.89.0",
-        "@sylphx/sdk": "0.10.2",
+        "@sylphx/sdk": "0.10.4",
         chalk: "^5.3.0",
         effect: "3.21.0",
         eventsource: "^2.0.2",
@@ -4608,7 +4608,8 @@ var init_auth = __esm({
       password: Schema38.String,
       name: Schema38.optional(Schema38.String),
       metadata: Schema38.optional(Schema38.Record({ key: Schema38.String, value: Schema38.Unknown })),
-      invitationToken: Schema38.optional(Schema38.String)
+      invitationToken: Schema38.optional(Schema38.String),
+      captchaToken: Schema38.optional(Schema38.String)
     });
     RegisterResponse = Schema38.Struct({
       requiresVerification: Schema38.optional(Schema38.Boolean),
@@ -6003,8 +6004,8 @@ var init_database = __esm({
       directHost: Schema48.optional(Schema48.NullOr(Schema48.String)),
       port: Schema48.optional(Schema48.Number),
       publicPort: Schema48.optional(Schema48.NullOr(Schema48.Number)),
-      dbUser: Schema48.optional(Schema48.String),
-      dbName: Schema48.optional(Schema48.String),
+      dbUser: Schema48.String,
+      dbName: Schema48.String,
       connectionString: Schema48.optional(Schema48.String),
       storageGb: Schema48.optional(Schema48.Number),
       env: Schema48.optional(Schema48.String),
@@ -6079,8 +6080,8 @@ var init_resources = __esm({
       /** Plaintext metadata — safe to return (not secret) */
       host: Schema49.NullOr(Schema49.String),
       port: Schema49.NullOr(Schema49.Number),
-      dbUser: Schema49.NullOr(Schema49.String),
-      dbName: Schema49.NullOr(Schema49.String),
+      dbUser: Schema49.String,
+      dbName: Schema49.String,
       clusterName: Schema49.NullOr(Schema49.String),
       branchName: Schema49.NullOr(Schema49.String),
       bindingCount: Schema49.Number,
@@ -8511,13 +8512,25 @@ var init_kv = __esm({
       value: KvValue,
       /** Expire in N seconds. */
       ex: Schema67.optional(Schema67.Number),
+      /** Expire in N milliseconds. */
+      px: Schema67.optional(Schema67.Number),
+      /** Unix timestamp (seconds) at which the key will expire. */
+      exat: Schema67.optional(Schema67.Number),
+      /** Unix timestamp (milliseconds) at which the key will expire. */
+      pxat: Schema67.optional(Schema67.Number),
       /** Only set if the key does not exist. */
       nx: Schema67.optional(Schema67.Boolean),
       /** Only set if the key exists. */
       xx: Schema67.optional(Schema67.Boolean)
     });
-    KvSetResult = Schema67.Struct({ ok: Schema67.Boolean });
-    KvGetResult = Schema67.Struct({ value: Schema67.NullOr(KvValue) });
+    KvSetResult = Schema67.Struct({
+      success: Schema67.Boolean,
+      created: Schema67.optional(Schema67.Boolean)
+    });
+    KvGetResult = Schema67.Struct({
+      value: Schema67.NullOr(KvValue),
+      ttl: Schema67.NullOr(Schema67.Number)
+    });
     KvDeleteResult = Schema67.Struct({ deleted: Schema67.Number });
     KvExistsResult = Schema67.Struct({ exists: Schema67.Boolean });
     KvIncrInput = Schema67.Struct({
@@ -8530,9 +8543,9 @@ var init_kv = __esm({
       seconds: Schema67.Number
     });
     KvRateLimitInput = Schema67.Struct({
-      identifier: Schema67.String,
+      key: Schema67.String,
       limit: Schema67.Number,
-      window: Schema67.Number
+      window: Schema67.String
     });
     KvRateLimitResult = Schema67.Struct({
       success: Schema67.Boolean,
@@ -9106,6 +9119,16 @@ var init_notifications = __esm({
       messageId: Schema72.optional(Schema72.String),
       /** Human-readable failure reason — present on `failed`. */
       reason: Schema72.optional(Schema72.String),
+      /** Canonical aggregate delivery count from the runtime API. */
+      sent: Schema72.optional(Schema72.Number),
+      /** Canonical aggregate failure count from the runtime API. */
+      failed: Schema72.optional(Schema72.Number),
+      /** Canonical per-platform success breakdown from the runtime API. */
+      platforms: Schema72.optional(Schema72.Struct({
+        web: Schema72.optional(Schema72.Number),
+        ios: Schema72.optional(Schema72.Number),
+        android: Schema72.optional(Schema72.Number)
+      })),
       /** Count of subscriptions the push was delivered to (SDK counter). */
       sentTo: Schema72.optional(Schema72.Number),
       /** Count of subscriptions that were pruned as expired (SDK counter). */
@@ -10822,7 +10845,7 @@ var init_privacy = __esm({
 
 // ../contract/dist/schemas/project-manifest.js
 import { Schema as Schema83 } from "effect";
-var Slug2, ManifestEnvName, ManifestRegion, MachineSize, BuildMachineSize, BuildpackName, ServiceType, DeployStrategy, WwwRedirect, ManifestProjectSection, ManifestBuildSection, ManifestDeploySection, ManifestServiceSection, ManifestEnvValue, ManifestDomainSection, PostgresTier, PostgresVersion, SearchTier, ManifestDatabaseEngine, ManifestSearchEngine, ManifestDatabaseResource, ManifestSearchResource, ManifestResourcesSection, ManifestCiSection, ManifestServiceOverride, ManifestEnvironmentOverride, ManifestEnvironmentsMap, SylphxManifest;
+var Slug2, ManifestEnvName, ManifestRegion, MachineSize, BuildMachineSize, BuildpackName, BuildStrategy, ServiceType, DeployStrategy, WwwRedirect, ManifestProjectSection, ManifestBuildSection, ManifestDeploySection, ManifestServiceBuildSection, ManifestServiceHealthSection, ManifestServiceSection, ManifestMigrationEngine, ManifestMigrationDestructivePolicy, ManifestMigrationsSection, ManifestDatabaseSection, ManifestEnvValue, ManifestDomainSection, ManifestManagedResourceTier, PostgresTier, PostgresVersion, SearchTier, KvTier, ManifestVolumeTier, ManifestVolumeAccessMode, ManifestDatabaseEngine, ManifestKvEngine, ManifestSearchEngine, ManifestDatabaseResource, ManifestKvResource, ManifestSearchResource, ManifestVolumeResource, ManifestResourcesSection, ManifestCiSection, ManifestServiceOverride, ManifestEnvironmentOverride, ManifestEnvironmentsMap, SylphxManifest;
 var init_project_manifest = __esm({
   "../contract/dist/schemas/project-manifest.js"() {
     "use strict";
@@ -10832,6 +10855,7 @@ var init_project_manifest = __esm({
     MachineSize = Schema83.Literal("nano", "micro", "small", "standard", "large", "xlarge");
     BuildMachineSize = Schema83.Literal("standard", "large", "xlarge");
     BuildpackName = Schema83.Literal("auto", "ruby", "node", "python", "static", "dockerfile");
+    BuildStrategy = Schema83.Literal("auto", "buildpack", "dockerfile", "nixpacks");
     ServiceType = Schema83.Literal("web", "worker", "cron", "function");
     DeployStrategy = Schema83.Literal("rolling", "blue-green", "immediate");
     WwwRedirect = Schema83.Literal("apex", "www", "none");
@@ -10856,8 +10880,12 @@ var init_project_manifest = __esm({
        * package.json / Gemfile / requirements.txt / Dockerfile.
        */
       buildpack: Schema83.optional(BuildpackName),
+      /** High-level build strategy alias used by current sylphx.toml files. */
+      strategy: Schema83.optional(BuildStrategy),
       /** Override path to Dockerfile (implies buildpack=dockerfile). */
       dockerfile: Schema83.optional(Schema83.String),
+      /** Docker build context path. `context` is the product-facing TOML alias. */
+      context: Schema83.optional(Schema83.String),
       /** Docker build context path (default: repo root). */
       docker_context: Schema83.optional(Schema83.String),
       /** Custom build command; overrides buildpack default. */
@@ -10884,10 +10912,26 @@ var init_project_manifest = __esm({
       /** Grace period before SIGKILL (seconds). */
       graceful_shutdown: Schema83.optional(Schema83.Number.pipe(Schema83.int(), Schema83.between(0, 300)))
     });
+    ManifestServiceBuildSection = Schema83.Struct({
+      strategy: Schema83.optional(BuildStrategy),
+      dockerfile: Schema83.optional(Schema83.String),
+      context: Schema83.optional(Schema83.String),
+      docker_context: Schema83.optional(Schema83.String),
+      build_command: Schema83.optional(Schema83.String)
+    });
+    ManifestServiceHealthSection = Schema83.Struct({
+      mode: Schema83.optional(Schema83.Literal("http", "tcp", "command")),
+      path: Schema83.optional(Schema83.String),
+      command: Schema83.optional(Schema83.String)
+    });
     ManifestServiceSection = Schema83.Struct({
       /** Service name — unique within project. Used as K8s Deployment name. */
       name: Slug2,
       type: ServiceType,
+      /** Per-service build override. Root [build] remains the default. */
+      build: Schema83.optional(ManifestServiceBuildSection),
+      /** Per-service health contract. Platform owns probe translation. */
+      health: Schema83.optional(ManifestServiceHealthSection),
       /** Container start command. */
       command: Schema83.optional(Schema83.String),
       /** Internal container port; required for `web`. */
@@ -10926,7 +10970,22 @@ var init_project_manifest = __esm({
       /** Per-service env var merge — refs entries from top-level [env]. */
       env: Schema83.optional(Schema83.Array(Schema83.String)),
       /** Per-service resource bindings (by resource name). */
-      resources: Schema83.optional(Schema83.Array(Slug2))
+      resources: Schema83.optional(Schema83.Array(Slug2)),
+      /** Paths whose changes should trigger this service in monorepos. */
+      watch_paths: Schema83.optional(Schema83.Array(Schema83.String))
+    });
+    ManifestMigrationEngine = Schema83.Literal("atlas", "drizzle", "prisma", "alembic", "flyway", "goose", "sqlx", "custom");
+    ManifestMigrationDestructivePolicy = Schema83.Literal("require-approval", "allow");
+    ManifestMigrationsSection = Schema83.Struct({
+      engine: ManifestMigrationEngine,
+      dir: Schema83.optional(Schema83.String),
+      image: Slug2,
+      command: Schema83.String.pipe(Schema83.minLength(1)),
+      timeout: Schema83.optional(Schema83.String),
+      destructive_policy: Schema83.optional(ManifestMigrationDestructivePolicy)
+    });
+    ManifestDatabaseSection = Schema83.Struct({
+      migrations: Schema83.optional(ManifestMigrationsSection)
     });
     ManifestEnvValue = Schema83.Union(Schema83.Struct({ value: Schema83.String }), Schema83.Struct({ from_secret: Schema83.String }), Schema83.Struct({ from_resource: Schema83.String, attr: Schema83.String }));
     ManifestDomainSection = Schema83.Struct({
@@ -10940,10 +10999,15 @@ var init_project_manifest = __esm({
       /** Alternate names (e.g. marketing domains pointing here). */
       aliases: Schema83.optional(Schema83.Array(Schema83.String))
     });
-    PostgresTier = Schema83.Literal("nano", "micro", "standard", "large", "xl");
+    ManifestManagedResourceTier = Schema83.Literal("nano", "micro", "standard", "large", "xl", "hobby", "starter", "pro", "business", "enterprise", "enterprise-2x", "enterprise-4x");
+    PostgresTier = ManifestManagedResourceTier;
     PostgresVersion = Schema83.Literal("15", "16", "17");
-    SearchTier = Schema83.Literal("micro", "standard");
+    SearchTier = ManifestManagedResourceTier;
+    KvTier = ManifestManagedResourceTier;
+    ManifestVolumeTier = ManifestManagedResourceTier;
+    ManifestVolumeAccessMode = Schema83.Literal("ReadWriteOnce", "ReadWriteMany");
     ManifestDatabaseEngine = Schema83.Literal("postgres");
+    ManifestKvEngine = Schema83.Literal("valkey");
     ManifestSearchEngine = Schema83.Literal("typesense");
     ManifestDatabaseResource = Schema83.Struct({
       /** Capability-specific engine. PostgreSQL is the first supported database engine. */
@@ -10957,6 +11021,12 @@ var init_project_manifest = __esm({
       /** Branch-per-preview (P0 gap #4 sibling). */
       branch_on_preview: Schema83.optional(Schema83.Boolean)
     });
+    ManifestKvResource = Schema83.Struct({
+      /** Capability-specific engine. Valkey is the first supported KV engine. */
+      engine: Schema83.optional(ManifestKvEngine),
+      tier: KvTier,
+      storage_gb: Schema83.optional(Schema83.Number.pipe(Schema83.int(), Schema83.between(1, 1e4)))
+    });
     ManifestSearchResource = Schema83.Struct({
       /** Capability-specific engine. Typesense is the first supported search engine. */
       engine: Schema83.optional(ManifestSearchEngine),
@@ -10964,9 +11034,31 @@ var init_project_manifest = __esm({
       storage_gb: Schema83.optional(Schema83.Number.pipe(Schema83.int(), Schema83.between(1, 1e4))),
       nodes: Schema83.optional(Schema83.Number.pipe(Schema83.int(), Schema83.between(1, 9)))
     });
+    ManifestVolumeResource = Schema83.Struct({
+      tier: ManifestVolumeTier,
+      storage_gb: Schema83.optional(Schema83.Number.pipe(Schema83.int(), Schema83.between(1, 1e4))),
+      /**
+       * ReadWriteMany is required when a volume is shared by multiple sandboxes,
+       * workers, or replicas. ReadWriteOnce remains valid for single-writer app
+       * disks.
+       */
+      access_mode: Schema83.optional(ManifestVolumeAccessMode),
+      /**
+       * Optional env-facing path metadata. This does not mount the volume into an
+       * app service by itself; service/task mounts stay explicit bindings.
+       */
+      mount_path: Schema83.optional(Schema83.String.pipe(Schema83.pattern(/^\//))),
+      /**
+       * Binding role controls env var prefix. Example: role="workspace" emits
+       * WORKSPACE_VOLUME_ID for a volume binding.
+       */
+      role: Schema83.optional(Slug2)
+    });
     ManifestResourcesSection = Schema83.Struct({
       database: Schema83.optional(ManifestDatabaseResource),
-      search: Schema83.optional(ManifestSearchResource)
+      kv: Schema83.optional(ManifestKvResource),
+      search: Schema83.optional(ManifestSearchResource),
+      volume: Schema83.optional(ManifestVolumeResource)
     });
     ManifestCiSection = Schema83.Struct({
       on_push: Schema83.optional(Schema83.Boolean),
@@ -11021,6 +11113,7 @@ var init_project_manifest = __esm({
       build: Schema83.optional(ManifestBuildSection),
       deploy: Schema83.optional(ManifestDeploySection),
       services: Schema83.optional(Schema83.Array(ManifestServiceSection)),
+      database: Schema83.optional(ManifestDatabaseSection),
       env: Schema83.optional(Schema83.Record({ key: Schema83.String, value: ManifestEnvValue })),
       domains: Schema83.optional(Schema83.Array(ManifestDomainSection)),
       environments: Schema83.optional(ManifestEnvironmentsMap),
@@ -11030,94 +11123,138 @@ var init_project_manifest = __esm({
   }
 });
 
-// ../contract/dist/schemas/project.js
+// ../contract/dist/endpoints/project-manifest.js
 import { Schema as Schema84 } from "effect";
+var IdPath2, ManifestGetResponse, ManifestPutResponse, projectManifestEndpoints;
+var init_project_manifest2 = __esm({
+  "../contract/dist/endpoints/project-manifest.js"() {
+    "use strict";
+    init_endpoint();
+    init_project_manifest();
+    IdPath2 = Schema84.Struct({ id: Schema84.String });
+    ManifestGetResponse = Schema84.Struct({
+      manifest: Schema84.NullOr(SylphxManifest),
+      version: Schema84.NullOr(Schema84.Number),
+      updatedAt: Schema84.NullOr(Schema84.String)
+    });
+    ManifestPutResponse = Schema84.Struct({
+      version: Schema84.Number,
+      updatedAt: Schema84.String
+    });
+    projectManifestEndpoints = {
+      get: defineEndpoint({
+        method: "GET",
+        path: "/projects/:id/manifest",
+        params: IdPath2,
+        response: ManifestGetResponse,
+        summary: "Fetch the latest persisted sylphx.toml manifest for a project",
+        description: "Returns the most recently pushed manifest. `manifest` is null when the project has not yet had `sylphx config push` invoked \u2014 callers should synthesise a starter from live state.",
+        tags: ["projects", "manifest"],
+        plane: "management"
+      }),
+      put: defineEndpoint({
+        method: "PUT",
+        path: "/projects/:id/manifest",
+        params: IdPath2,
+        body: SylphxManifest,
+        response: ManifestPutResponse,
+        summary: "Persist a new sylphx.toml manifest version for a project",
+        description: "Inserts a new row in `project_manifests` with an incremented version. Never mutates prior versions \u2014 history + rollback come for free.",
+        tags: ["projects", "manifest"],
+        plane: "management"
+      })
+    };
+  }
+});
+
+// ../contract/dist/schemas/project.js
+import { Schema as Schema85 } from "effect";
 var ProjectEnvironmentSummary, Project, CreateProjectResult, DeleteProjectResult, CreateProjectInput, UpdateProjectInput;
 var init_project = __esm({
   "../contract/dist/schemas/project.js"() {
     "use strict";
     init_ids();
-    ProjectEnvironmentSummary = Schema84.Struct({
+    ProjectEnvironmentSummary = Schema85.Struct({
       id: EnvironmentId,
-      slug: Schema84.optional(Schema84.String),
-      name: Schema84.String,
-      envType: Schema84.optional(Schema84.String),
-      isActive: Schema84.optional(Schema84.Boolean),
-      publicKey: Schema84.optional(Schema84.NullOr(Schema84.String)),
-      secretKeyPrefix: Schema84.optional(Schema84.NullOr(Schema84.String)),
-      deployAppId: Schema84.optional(Schema84.NullOr(Schema84.String)),
-      namespace: Schema84.optional(Schema84.NullOr(Schema84.String)),
-      githubRepo: Schema84.optional(Schema84.NullOr(Schema84.String)),
-      githubBranch: Schema84.optional(Schema84.NullOr(Schema84.String)),
-      customDomains: Schema84.optional(Schema84.NullOr(Schema84.Array(Schema84.String))),
-      createdAt: Schema84.optional(Schema84.String),
-      updatedAt: Schema84.optional(Schema84.String)
-    });
-    Project = Schema84.Struct({
+      slug: Schema85.optional(Schema85.String),
+      name: Schema85.String,
+      envType: Schema85.optional(Schema85.String),
+      isActive: Schema85.optional(Schema85.Boolean),
+      publicKey: Schema85.optional(Schema85.NullOr(Schema85.String)),
+      secretKeyPrefix: Schema85.optional(Schema85.NullOr(Schema85.String)),
+      deployAppId: Schema85.optional(Schema85.NullOr(Schema85.String)),
+      namespace: Schema85.optional(Schema85.NullOr(Schema85.String)),
+      githubRepo: Schema85.optional(Schema85.NullOr(Schema85.String)),
+      githubBranch: Schema85.optional(Schema85.NullOr(Schema85.String)),
+      customDomains: Schema85.optional(Schema85.NullOr(Schema85.Array(Schema85.String))),
+      createdAt: Schema85.optional(Schema85.String),
+      updatedAt: Schema85.optional(Schema85.String)
+    });
+    Project = Schema85.Struct({
       id: ProjectId,
-      slug: Schema84.String,
-      name: Schema84.String,
-      ref: Schema84.optional(Schema84.String),
-      description: Schema84.optional(Schema84.NullOr(Schema84.String)),
-      orgId: Schema84.optional(OrgId),
-      isActive: Schema84.optional(Schema84.Boolean),
-      sdkUrl: Schema84.optional(Schema84.String),
+      slug: Schema85.String,
+      name: Schema85.String,
+      ref: Schema85.optional(Schema85.String),
+      description: Schema85.optional(Schema85.NullOr(Schema85.String)),
+      orgId: Schema85.optional(OrgId),
+      isActive: Schema85.optional(Schema85.Boolean),
+      sdkUrl: Schema85.optional(Schema85.String),
       /** Ephemeral status surfaced from POST /projects; resources are declared separately. */
-      infraStatus: Schema84.optional(Schema84.String),
-      domains: Schema84.optional(Schema84.NullOr(Schema84.Array(Schema84.String))),
-      webhookUrl: Schema84.optional(Schema84.NullOr(Schema84.String)),
-      webhookEvents: Schema84.optional(Schema84.NullOr(Schema84.Array(Schema84.String))),
-      enabledOAuthProviders: Schema84.optional(Schema84.NullOr(Schema84.Array(Schema84.String))),
-      buildMachineType: Schema84.optional(Schema84.String),
-      settings: Schema84.optional(Schema84.NullOr(Schema84.Record({ key: Schema84.String, value: Schema84.Unknown }))),
-      createdAt: Schema84.optional(Schema84.String),
-      updatedAt: Schema84.optional(Schema84.String),
-      environments: Schema84.optional(Schema84.Array(ProjectEnvironmentSummary))
-    });
-    CreateProjectResult = Schema84.Struct({
+      infraStatus: Schema85.optional(Schema85.String),
+      domains: Schema85.optional(Schema85.NullOr(Schema85.Array(Schema85.String))),
+      webhookUrl: Schema85.optional(Schema85.NullOr(Schema85.String)),
+      webhookEvents: Schema85.optional(Schema85.NullOr(Schema85.Array(Schema85.String))),
+      enabledOAuthProviders: Schema85.optional(Schema85.NullOr(Schema85.Array(Schema85.String))),
+      buildMachineType: Schema85.optional(Schema85.String),
+      settings: Schema85.optional(Schema85.NullOr(Schema85.Record({ key: Schema85.String, value: Schema85.Unknown }))),
+      createdAt: Schema85.optional(Schema85.String),
+      updatedAt: Schema85.optional(Schema85.String),
+      environments: Schema85.optional(Schema85.Array(ProjectEnvironmentSummary))
+    });
+    CreateProjectResult = Schema85.Struct({
       app: Project
     });
-    DeleteProjectResult = Schema84.Struct({
-      deleted: Schema84.Boolean,
+    DeleteProjectResult = Schema85.Struct({
+      deleted: Schema85.Boolean,
       projectId: ProjectId,
-      queued: Schema84.Boolean,
-      warnings: Schema84.optional(Schema84.Array(Schema84.String))
+      queued: Schema85.Boolean,
+      warnings: Schema85.optional(Schema85.Array(Schema85.String))
     });
-    CreateProjectInput = Schema84.Struct({
-      name: Schema84.String,
-      slug: Schema84.String,
-      description: Schema84.optional(Schema84.String),
-      gitRepository: Schema84.optional(Schema84.String),
-      gitBranch: Schema84.optional(Schema84.String),
-      buildPack: Schema84.optional(Schema84.String),
-      dockerImage: Schema84.optional(Schema84.String),
-      port: Schema84.optional(Schema84.Number),
-      domain: Schema84.optional(Schema84.String)
+    CreateProjectInput = Schema85.Struct({
+      name: Schema85.String,
+      slug: Schema85.String,
+      description: Schema85.optional(Schema85.String),
+      gitRepository: Schema85.optional(Schema85.String),
+      gitBranch: Schema85.optional(Schema85.String),
+      buildPack: Schema85.optional(Schema85.String),
+      dockerImage: Schema85.optional(Schema85.String),
+      port: Schema85.optional(Schema85.Number),
+      domain: Schema85.optional(Schema85.String)
     });
-    UpdateProjectInput = Schema84.Struct({
-      name: Schema84.optional(Schema84.String),
-      description: Schema84.optional(Schema84.NullOr(Schema84.String)),
-      domains: Schema84.optional(Schema84.Array(Schema84.String)),
-      webhookUrl: Schema84.optional(Schema84.NullOr(Schema84.String)),
-      webhookEvents: Schema84.optional(Schema84.Array(Schema84.String)),
-      enabledOAuthProviders: Schema84.optional(Schema84.Array(Schema84.String)),
-      buildMachineType: Schema84.optional(Schema84.Literal("standard", "large", "xlarge"))
+    UpdateProjectInput = Schema85.Struct({
+      name: Schema85.optional(Schema85.String),
+      description: Schema85.optional(Schema85.NullOr(Schema85.String)),
+      domains: Schema85.optional(Schema85.Array(Schema85.String)),
+      webhookUrl: Schema85.optional(Schema85.NullOr(Schema85.String)),
+      webhookEvents: Schema85.optional(Schema85.Array(Schema85.String)),
+      enabledOAuthProviders: Schema85.optional(Schema85.Array(Schema85.String)),
+      buildMachineType: Schema85.optional(Schema85.Literal("standard", "large", "xlarge"))
     });
   }
 });
 
 // ../contract/dist/endpoints/projects.js
-import { Schema as Schema85 } from "effect";
-var IdPath2, ListResponse, projectsEndpoints2;
+import { Schema as Schema86 } from "effect";
+var IdPath3, ListResponse, projectsEndpoints2;
 var init_projects = __esm({
   "../contract/dist/endpoints/projects.js"() {
     "use strict";
     init_endpoint();
     init_project();
-    IdPath2 = Schema85.Struct({ id: Schema85.String });
-    ListResponse = Schema85.Struct({
-      object: Schema85.Literal("list"),
-      data: Schema85.Array(Project)
+    IdPath3 = Schema86.Struct({ id: Schema86.String });
+    ListResponse = Schema86.Struct({
+      object: Schema86.Literal("list"),
+      data: Schema86.Array(Project)
     });
     projectsEndpoints2 = {
       list: defineEndpoint({
@@ -11139,7 +11276,7 @@ var init_projects = __esm({
       get: defineEndpoint({
         method: "GET",
         path: "/projects/:id",
-        params: IdPath2,
+        params: IdPath3,
         response: Project,
         summary: "Get project detail by id or slug",
         tags: ["projects"]
@@ -11147,7 +11284,7 @@ var init_projects = __esm({
       update: defineEndpoint({
         method: "PATCH",
         path: "/projects/:id",
-        params: IdPath2,
+        params: IdPath3,
         body: UpdateProjectInput,
         response: Project,
         summary: "Update project metadata, webhooks, OAuth providers, or build machine tier",
@@ -11156,7 +11293,7 @@ var init_projects = __esm({
       delete: defineEndpoint({
         method: "DELETE",
         path: "/projects/:id",
-        params: IdPath2,
+        params: IdPath3,
         response: DeleteProjectResult,
         summary: "Soft-delete a project \u2014 environments transition to `terminating`",
         tags: ["projects"]
@@ -11166,440 +11303,440 @@ var init_projects = __esm({
 });
 
 // ../contract/dist/schemas/realtime.js
-import { Schema as Schema86 } from "effect";
+import { Schema as Schema87 } from "effect";
 var ChannelName, StreamMessageId, StreamMessage, RealtimeEmitInput, RealtimeEmitResult, RealtimeHistoryQuery, RealtimeHistoryResult;
 var init_realtime = __esm({
   "../contract/dist/schemas/realtime.js"() {
     "use strict";
-    ChannelName = Schema86.String.pipe(Schema86.minLength(1), Schema86.brand("ChannelName"));
-    StreamMessageId = Schema86.String.pipe(Schema86.brand("StreamMessageId"));
-    StreamMessage = Schema86.Struct({
-      id: Schema86.String,
-      channel: Schema86.String,
-      event: Schema86.String,
-      data: Schema86.Unknown,
-      timestamp: Schema86.Number
+    ChannelName = Schema87.String.pipe(Schema87.minLength(1), Schema87.brand("ChannelName"));
+    StreamMessageId = Schema87.String.pipe(Schema87.brand("StreamMessageId"));
+    StreamMessage = Schema87.Struct({
+      id: Schema87.String,
+      channel: Schema87.String,
+      event: Schema87.String,
+      data: Schema87.Unknown,
+      timestamp: Schema87.Number
     });
-    RealtimeEmitInput = Schema86.Struct({
-      channel: Schema86.String,
-      event: Schema86.String,
-      data: Schema86.Unknown
+    RealtimeEmitInput = Schema87.Struct({
+      channel: Schema87.String,
+      event: Schema87.String,
+      data: Schema87.Unknown
     });
-    RealtimeEmitResult = Schema86.Struct({
-      id: Schema86.String,
-      channel: Schema86.String
+    RealtimeEmitResult = Schema87.Struct({
+      id: Schema87.String,
+      channel: Schema87.String
     });
-    RealtimeHistoryQuery = Schema86.Struct({
-      channel: Schema86.String,
-      limit: Schema86.optional(Schema86.String),
-      after: Schema86.optional(Schema86.String)
+    RealtimeHistoryQuery = Schema87.Struct({
+      channel: Schema87.String,
+      limit: Schema87.optional(Schema87.String),
+      after: Schema87.optional(Schema87.String)
     });
-    RealtimeHistoryResult = Schema86.Struct({
-      messages: Schema86.Array(StreamMessage)
+    RealtimeHistoryResult = Schema87.Struct({
+      messages: Schema87.Array(StreamMessage)
     });
   }
 });
 
 // ../contract/dist/schemas/realtime-admin.js
-import { Schema as Schema87 } from "effect";
+import { Schema as Schema88 } from "effect";
 var RealtimeAdminProjectIdQuery, RealtimeAdminChannelNameParams, RealtimeAdminStatusResult, RealtimeAdminChannel, RealtimeAdminListChannelsResult, RealtimeAdminCreateChannelInput, RealtimeAdminCreateChannelResult, RealtimeAdminDeleteChannelResult;
 var init_realtime_admin = __esm({
   "../contract/dist/schemas/realtime-admin.js"() {
     "use strict";
-    RealtimeAdminProjectIdQuery = Schema87.Struct({ projectId: Schema87.String });
-    RealtimeAdminChannelNameParams = Schema87.Struct({ channelName: Schema87.String });
-    RealtimeAdminStatusResult = Schema87.Struct({
-      available: Schema87.Boolean,
-      provider: Schema87.String
-    });
-    RealtimeAdminChannel = Schema87.Struct({
-      name: Schema87.String,
-      activeConnections: Schema87.Number,
-      messagesPerHour: Schema87.Number,
-      status: Schema87.Literal("active", "empty")
-    });
-    RealtimeAdminListChannelsResult = Schema87.Struct({
-      channels: Schema87.Array(RealtimeAdminChannel),
-      count: Schema87.Number
-    });
-    RealtimeAdminCreateChannelInput = Schema87.Struct({
-      projectId: Schema87.String,
-      name: Schema87.String
+    RealtimeAdminProjectIdQuery = Schema88.Struct({ projectId: Schema88.String });
+    RealtimeAdminChannelNameParams = Schema88.Struct({ channelName: Schema88.String });
+    RealtimeAdminStatusResult = Schema88.Struct({
+      available: Schema88.Boolean,
+      provider: Schema88.String
+    });
+    RealtimeAdminChannel = Schema88.Struct({
+      name: Schema88.String,
+      activeConnections: Schema88.Number,
+      messagesPerHour: Schema88.Number,
+      status: Schema88.Literal("active", "empty")
+    });
+    RealtimeAdminListChannelsResult = Schema88.Struct({
+      channels: Schema88.Array(RealtimeAdminChannel),
+      count: Schema88.Number
+    });
+    RealtimeAdminCreateChannelInput = Schema88.Struct({
+      projectId: Schema88.String,
+      name: Schema88.String
     });
-    RealtimeAdminCreateChannelResult = Schema87.Struct({ name: Schema87.String });
-    RealtimeAdminDeleteChannelResult = Schema87.Struct({ success: Schema87.Boolean });
+    RealtimeAdminCreateChannelResult = Schema88.Struct({ name: Schema88.String });
+    RealtimeAdminDeleteChannelResult = Schema88.Struct({ success: Schema88.Boolean });
   }
 });
 
 // ../contract/dist/schemas/referrals-admin.js
-import { Schema as Schema88 } from "effect";
+import { Schema as Schema89 } from "effect";
 var ReferralStatus, ReferralRewardType, ReferralUserRef, Referral, ReferralDetail, ListReferralsQuery, GetReferralQuery, CreateReferralInput, GetReferralStatsQuery, ExpireReferralInput, ListReferralsResult, CreateReferralResult, ExpireReferralResult, DailyTrendEntry, ByRewardTypeEntry, ByProjectEntry, TopReferrerEntry, GetReferralStatsResult;
 var init_referrals_admin = __esm({
   "../contract/dist/schemas/referrals-admin.js"() {
     "use strict";
-    ReferralStatus = Schema88.Literal("pending", "completed", "expired");
-    ReferralRewardType = Schema88.Literal("points", "premium_trial", "discount", "credit");
-    ReferralUserRef = Schema88.Struct({
-      id: Schema88.String,
-      email: Schema88.String,
-      name: Schema88.NullOr(Schema88.String)
-    });
-    Referral = Schema88.Struct({
-      id: Schema88.String,
-      projectId: Schema88.String,
-      projectName: Schema88.String,
-      code: Schema88.String,
-      referrer: Schema88.NullOr(ReferralUserRef),
-      referredUser: Schema88.NullOr(ReferralUserRef),
+    ReferralStatus = Schema89.Literal("pending", "completed", "expired");
+    ReferralRewardType = Schema89.Literal("points", "premium_trial", "discount", "credit");
+    ReferralUserRef = Schema89.Struct({
+      id: Schema89.String,
+      email: Schema89.String,
+      name: Schema89.NullOr(Schema89.String)
+    });
+    Referral = Schema89.Struct({
+      id: Schema89.String,
+      projectId: Schema89.String,
+      projectName: Schema89.String,
+      code: Schema89.String,
+      referrer: Schema89.NullOr(ReferralUserRef),
+      referredUser: Schema89.NullOr(ReferralUserRef),
       status: ReferralStatus,
       rewardType: ReferralRewardType,
-      createdAt: Schema88.String,
-      completedAt: Schema88.NullOr(Schema88.String)
-    });
-    ReferralDetail = Schema88.Struct({
-      id: Schema88.String,
-      projectId: Schema88.String,
-      projectName: Schema88.String,
-      code: Schema88.String,
-      referrer: Schema88.NullOr(ReferralUserRef),
-      referredUser: Schema88.NullOr(ReferralUserRef),
+      createdAt: Schema89.String,
+      completedAt: Schema89.NullOr(Schema89.String)
+    });
+    ReferralDetail = Schema89.Struct({
+      id: Schema89.String,
+      projectId: Schema89.String,
+      projectName: Schema89.String,
+      code: Schema89.String,
+      referrer: Schema89.NullOr(ReferralUserRef),
+      referredUser: Schema89.NullOr(ReferralUserRef),
       status: ReferralStatus,
       rewardType: ReferralRewardType,
-      createdAt: Schema88.String,
-      completedAt: Schema88.NullOr(Schema88.String),
-      metadata: Schema88.NullOr(Schema88.Record({ key: Schema88.String, value: Schema88.Unknown }))
-    });
-    ListReferralsQuery = Schema88.Struct({
-      projectId: Schema88.optional(Schema88.String),
-      environmentId: Schema88.optional(Schema88.String),
-      limit: Schema88.optional(Schema88.String),
-      offset: Schema88.optional(Schema88.String)
-    });
-    GetReferralQuery = Schema88.Struct({
-      projectId: Schema88.String
-    });
-    CreateReferralInput = Schema88.Struct({
-      projectId: Schema88.String,
-      referrerId: Schema88.String,
-      code: Schema88.optional(Schema88.String),
-      rewardType: Schema88.optional(ReferralRewardType)
-    });
-    GetReferralStatsQuery = Schema88.Struct({
-      projectId: Schema88.optional(Schema88.String),
-      environmentId: Schema88.optional(Schema88.String),
-      days: Schema88.optional(Schema88.String)
-    });
-    ExpireReferralInput = Schema88.Struct({
-      projectId: Schema88.String
-    });
-    ListReferralsResult = Schema88.Array(Referral);
-    CreateReferralResult = Schema88.Struct({
-      id: Schema88.String,
-      code: Schema88.String
-    });
-    ExpireReferralResult = Schema88.Struct({
-      success: Schema88.Boolean
-    });
-    DailyTrendEntry = Schema88.Struct({
-      date: Schema88.String,
-      created: Schema88.Number,
-      completed: Schema88.Number
-    });
-    ByRewardTypeEntry = Schema88.Struct({
+      createdAt: Schema89.String,
+      completedAt: Schema89.NullOr(Schema89.String),
+      metadata: Schema89.NullOr(Schema89.Record({ key: Schema89.String, value: Schema89.Unknown }))
+    });
+    ListReferralsQuery = Schema89.Struct({
+      projectId: Schema89.optional(Schema89.String),
+      environmentId: Schema89.optional(Schema89.String),
+      limit: Schema89.optional(Schema89.String),
+      offset: Schema89.optional(Schema89.String)
+    });
+    GetReferralQuery = Schema89.Struct({
+      projectId: Schema89.String
+    });
+    CreateReferralInput = Schema89.Struct({
+      projectId: Schema89.String,
+      referrerId: Schema89.String,
+      code: Schema89.optional(Schema89.String),
+      rewardType: Schema89.optional(ReferralRewardType)
+    });
+    GetReferralStatsQuery = Schema89.Struct({
+      projectId: Schema89.optional(Schema89.String),
+      environmentId: Schema89.optional(Schema89.String),
+      days: Schema89.optional(Schema89.String)
+    });
+    ExpireReferralInput = Schema89.Struct({
+      projectId: Schema89.String
+    });
+    ListReferralsResult = Schema89.Array(Referral);
+    CreateReferralResult = Schema89.Struct({
+      id: Schema89.String,
+      code: Schema89.String
+    });
+    ExpireReferralResult = Schema89.Struct({
+      success: Schema89.Boolean
+    });
+    DailyTrendEntry = Schema89.Struct({
+      date: Schema89.String,
+      created: Schema89.Number,
+      completed: Schema89.Number
+    });
+    ByRewardTypeEntry = Schema89.Struct({
       rewardType: ReferralRewardType,
-      total: Schema88.Number,
-      completed: Schema88.Number,
-      conversionRate: Schema88.Number
+      total: Schema89.Number,
+      completed: Schema89.Number,
+      conversionRate: Schema89.Number
     });
-    ByProjectEntry = Schema88.Struct({
-      projectId: Schema88.String,
-      total: Schema88.Number,
-      completed: Schema88.Number,
-      conversionRate: Schema88.Number
+    ByProjectEntry = Schema89.Struct({
+      projectId: Schema89.String,
+      total: Schema89.Number,
+      completed: Schema89.Number,
+      conversionRate: Schema89.Number
     });
-    TopReferrerEntry = Schema88.Struct({
-      referrerId: Schema88.String,
-      totalReferrals: Schema88.Number,
-      completedReferrals: Schema88.Number
+    TopReferrerEntry = Schema89.Struct({
+      referrerId: Schema89.String,
+      totalReferrals: Schema89.Number,
+      completedReferrals: Schema89.Number
     });
-    GetReferralStatsResult = Schema88.Struct({
-      overall: Schema88.Struct({
-        total: Schema88.Number,
-        completed: Schema88.Number,
-        pending: Schema88.Number,
-        expired: Schema88.Number,
-        conversionRate: Schema88.Number
+    GetReferralStatsResult = Schema89.Struct({
+      overall: Schema89.Struct({
+        total: Schema89.Number,
+        completed: Schema89.Number,
+        pending: Schema89.Number,
+        expired: Schema89.Number,
+        conversionRate: Schema89.Number
       }),
-      period: Schema88.Struct({
-        days: Schema88.Number,
-        since: Schema88.String,
-        created: Schema88.Number,
-        completed: Schema88.Number,
-        conversionRate: Schema88.Number
+      period: Schema89.Struct({
+        days: Schema89.Number,
+        since: Schema89.String,
+        created: Schema89.Number,
+        completed: Schema89.Number,
+        conversionRate: Schema89.Number
       }),
-      byRewardType: Schema88.Array(ByRewardTypeEntry),
-      byProject: Schema88.Array(ByProjectEntry),
-      dailyTrend: Schema88.Array(DailyTrendEntry),
-      topReferrers: Schema88.Array(TopReferrerEntry)
+      byRewardType: Schema89.Array(ByRewardTypeEntry),
+      byProject: Schema89.Array(ByProjectEntry),
+      dailyTrend: Schema89.Array(DailyTrendEntry),
+      topReferrers: Schema89.Array(TopReferrerEntry)
     });
   }
 });
 
 // ../contract/dist/schemas/refresh.js
-import { Schema as Schema89 } from "effect";
+import { Schema as Schema90 } from "effect";
 var RefreshTokenInput, RefreshTokenResult, LogoutInput, LogoutResult;
 var init_refresh = __esm({
   "../contract/dist/schemas/refresh.js"() {
     "use strict";
-    RefreshTokenInput = Schema89.Struct({ refresh_token: Schema89.String });
-    RefreshTokenResult = Schema89.Struct({
-      access_token: Schema89.String,
-      refresh_token: Schema89.String,
-      token_type: Schema89.Literal("Bearer"),
-      expires_in: Schema89.Number,
-      refresh_expires_at: Schema89.String
+    RefreshTokenInput = Schema90.Struct({ refresh_token: Schema90.String });
+    RefreshTokenResult = Schema90.Struct({
+      access_token: Schema90.String,
+      refresh_token: Schema90.String,
+      token_type: Schema90.Literal("Bearer"),
+      expires_in: Schema90.Number,
+      refresh_expires_at: Schema90.String
     });
-    LogoutInput = Schema89.Struct({ refresh_token: Schema89.String });
-    LogoutResult = Schema89.Struct({ revoked: Schema89.Boolean });
+    LogoutInput = Schema90.Struct({ refresh_token: Schema90.String });
+    LogoutResult = Schema90.Struct({ revoked: Schema90.Boolean });
   }
 });
 
 // ../contract/dist/schemas/region.js
-import { Schema as Schema90 } from "effect";
+import { Schema as Schema91 } from "effect";
 var RegionStatus, Region, ListRegionsResult;
 var init_region = __esm({
   "../contract/dist/schemas/region.js"() {
     "use strict";
-    RegionStatus = Schema90.Literal("coming-soon", "active", "decommissioned");
-    Region = Schema90.Struct({
+    RegionStatus = Schema91.Literal("coming-soon", "active", "decommissioned");
+    Region = Schema91.Struct({
       /** Internal TypeID (rarely used by clients; slug is the canonical handle). */
-      id: Schema90.String,
+      id: Schema91.String,
       /** DNS-safe slug — e.g. `eu-north-1`. Globally unique, immutable. */
-      slug: Schema90.String,
+      slug: Schema91.String,
       /** Human-readable display name — e.g. `Europe (Hetzner Finland)`. */
-      name: Schema90.String,
+      name: Schema91.String,
       /**
        * K8s API server endpoint for the region's cluster. NULL while
        * `status='coming-soon'` — the region exists as a catalog placeholder.
        * Always redacted to non-operators (the Management API may return
        * `null` even for GA regions).
        */
-      clusterEndpoint: Schema90.NullOr(Schema90.String),
+      clusterEndpoint: Schema91.NullOr(Schema91.String),
       status: RegionStatus,
       /** Data-center latitude for "nearest region" latency estimation. */
-      locationLat: Schema90.NullOr(Schema90.String),
+      locationLat: Schema91.NullOr(Schema91.String),
       /** Data-center longitude for "nearest region" latency estimation. */
-      locationLng: Schema90.NullOr(Schema90.String),
+      locationLng: Schema91.NullOr(Schema91.String),
       /** IPv4 CIDR range of the region's Gateway LB pool. Nullable. */
-      gatewayIpRange: Schema90.NullOr(Schema90.String),
-      createdAt: Schema90.String
+      gatewayIpRange: Schema91.NullOr(Schema91.String),
+      createdAt: Schema91.String
     });
-    ListRegionsResult = Schema90.Struct({
-      regions: Schema90.Array(Region)
+    ListRegionsResult = Schema91.Struct({
+      regions: Schema91.Array(Region)
     });
   }
 });
 
 // ../contract/dist/schemas/runners.js
-import { Schema as Schema91 } from "effect";
+import { Schema as Schema92 } from "effect";
 var RunnerPlatform, RunnerArch, Runner, RunnerJob, RunnerIdParams, CreateRunnerInput, ListRunnersResult, CreateRunnerResult, DeleteRunnerResult, ListRunnerJobsResult;
 var init_runners = __esm({
   "../contract/dist/schemas/runners.js"() {
     "use strict";
-    RunnerPlatform = Schema91.Literal("linux", "macos", "windows");
-    RunnerArch = Schema91.Literal("x64", "arm64");
-    Runner = Schema91.Struct({
-      id: Schema91.String,
-      orgId: Schema91.String,
-      name: Schema91.String,
-      platform: Schema91.String,
-      arch: Schema91.String,
-      version: Schema91.NullOr(Schema91.String),
-      status: Schema91.String,
-      lastSeenAt: Schema91.NullOr(Schema91.String),
-      createdAt: Schema91.String
+    RunnerPlatform = Schema92.Literal("linux", "macos", "windows");
+    RunnerArch = Schema92.Literal("x64", "arm64");
+    Runner = Schema92.Struct({
+      id: Schema92.String,
+      orgId: Schema92.String,
+      name: Schema92.String,
+      platform: Schema92.String,
+      arch: Schema92.String,
+      version: Schema92.NullOr(Schema92.String),
+      status: Schema92.String,
+      lastSeenAt: Schema92.NullOr(Schema92.String),
+      createdAt: Schema92.String
     });
-    RunnerJob = Schema91.Struct({
-      id: Schema91.String,
-      runnerId: Schema91.NullOr(Schema91.String),
-      envId: Schema91.String,
-      orgId: Schema91.String,
-      status: Schema91.String,
-      platform: Schema91.NullOr(Schema91.String),
-      gitRepo: Schema91.String,
-      gitBranch: Schema91.String,
-      gitCommit: Schema91.NullOr(Schema91.String),
-      buildCommand: Schema91.NullOr(Schema91.String),
-      exitCode: Schema91.NullOr(Schema91.String),
-      startedAt: Schema91.NullOr(Schema91.String),
-      finishedAt: Schema91.NullOr(Schema91.String),
-      createdAt: Schema91.String
+    RunnerJob = Schema92.Struct({
+      id: Schema92.String,
+      runnerId: Schema92.NullOr(Schema92.String),
+      envId: Schema92.String,
+      orgId: Schema92.String,
+      status: Schema92.String,
+      platform: Schema92.NullOr(Schema92.String),
+      gitRepo: Schema92.String,
+      gitBranch: Schema92.String,
+      gitCommit: Schema92.NullOr(Schema92.String),
+      buildCommand: Schema92.NullOr(Schema92.String),
+      exitCode: Schema92.NullOr(Schema92.String),
+      startedAt: Schema92.NullOr(Schema92.String),
+      finishedAt: Schema92.NullOr(Schema92.String),
+      createdAt: Schema92.String
     });
-    RunnerIdParams = Schema91.Struct({ runnerId: Schema91.String });
-    CreateRunnerInput = Schema91.Struct({
-      name: Schema91.String,
+    RunnerIdParams = Schema92.Struct({ runnerId: Schema92.String });
+    CreateRunnerInput = Schema92.Struct({
+      name: Schema92.String,
       platform: RunnerPlatform,
       arch: RunnerArch
     });
-    ListRunnersResult = Schema91.Struct({ runners: Schema91.Array(Runner) });
-    CreateRunnerResult = Schema91.Struct({
-      runnerId: Schema91.String,
-      registrationToken: Schema91.String
+    ListRunnersResult = Schema92.Struct({ runners: Schema92.Array(Runner) });
+    CreateRunnerResult = Schema92.Struct({
+      runnerId: Schema92.String,
+      registrationToken: Schema92.String
     });
-    DeleteRunnerResult = Schema91.Struct({ success: Schema91.Boolean });
-    ListRunnerJobsResult = Schema91.Struct({ jobs: Schema91.Array(RunnerJob) });
+    DeleteRunnerResult = Schema92.Struct({ success: Schema92.Boolean });
+    ListRunnerJobsResult = Schema92.Struct({ jobs: Schema92.Array(RunnerJob) });
   }
 });
 
 // ../contract/dist/schemas/saml.js
-import { Schema as Schema92 } from "effect";
+import { Schema as Schema93 } from "effect";
 var SAMLProviderType, SAMLNameIdFormat, SAMLSignatureAlgorithm, SAMLProviderStatus, SAMLAttributeMapping, SAMLProvider, SAMLAuthLog, SAMLIdPTemplate, SAMLNameIdFormatOption, SAMLSignatureAlgorithmOption, GetSAMLProviderQuery, GetSAMLMetadataQuery, GetSAMLLogsQuery, CreateSAMLProviderInput, UpdateSAMLProviderInput, SetSAMLProviderStatusInput, DeleteSAMLProviderInput, TestSAMLConfigInput, GetSAMLProviderResult, CreateSAMLProviderResult, UpdateSAMLProviderResult, SetSAMLProviderStatusResult, DeleteSAMLProviderResult, GetSAMLMetadataResult, GetSAMLLogsResult, TestSAMLConfigResult, ListSAMLIdPTemplatesResult, ListSAMLNameIdFormatsResult, ListSAMLSignatureAlgorithmsResult;
 var init_saml = __esm({
   "../contract/dist/schemas/saml.js"() {
     "use strict";
-    SAMLProviderType = Schema92.Literal("okta", "azure_ad", "google_workspace", "onelogin", "ping_identity", "jumpcloud", "custom");
-    SAMLNameIdFormat = Schema92.Literal("email", "persistent", "transient", "unspecified");
-    SAMLSignatureAlgorithm = Schema92.Literal("rsa-sha256", "rsa-sha384", "rsa-sha512");
-    SAMLProviderStatus = Schema92.Literal("pending", "active", "disabled", "error");
-    SAMLAttributeMapping = Schema92.Struct({
-      email: Schema92.optional(Schema92.String),
-      firstName: Schema92.optional(Schema92.String),
-      lastName: Schema92.optional(Schema92.String),
-      displayName: Schema92.optional(Schema92.String),
-      groups: Schema92.optional(Schema92.String)
-    });
-    SAMLProvider = Schema92.Struct({
-      id: Schema92.String,
-      name: Schema92.String,
+    SAMLProviderType = Schema93.Literal("okta", "azure_ad", "google_workspace", "onelogin", "ping_identity", "jumpcloud", "custom");
+    SAMLNameIdFormat = Schema93.Literal("email", "persistent", "transient", "unspecified");
+    SAMLSignatureAlgorithm = Schema93.Literal("rsa-sha256", "rsa-sha384", "rsa-sha512");
+    SAMLProviderStatus = Schema93.Literal("pending", "active", "disabled", "error");
+    SAMLAttributeMapping = Schema93.Struct({
+      email: Schema93.optional(Schema93.String),
+      firstName: Schema93.optional(Schema93.String),
+      lastName: Schema93.optional(Schema93.String),
+      displayName: Schema93.optional(Schema93.String),
+      groups: Schema93.optional(Schema93.String)
+    });
+    SAMLProvider = Schema93.Struct({
+      id: Schema93.String,
+      name: Schema93.String,
       type: SAMLProviderType,
       status: SAMLProviderStatus,
-      entityId: Schema92.String,
-      ssoUrl: Schema92.String,
-      sloUrl: Schema92.NullOr(Schema92.String),
+      entityId: Schema93.String,
+      ssoUrl: Schema93.String,
+      sloUrl: Schema93.NullOr(Schema93.String),
       nameIdFormat: SAMLNameIdFormat,
       signatureAlgorithm: SAMLSignatureAlgorithm,
-      allowedDomains: Schema92.NullOr(Schema92.Array(Schema92.String)),
-      enforceSSO: Schema92.Boolean,
-      attributeMapping: Schema92.NullOr(SAMLAttributeMapping),
-      spEntityId: Schema92.NullOr(Schema92.String),
-      spAcsUrl: Schema92.NullOr(Schema92.String),
-      certificateExpiresAt: Schema92.NullOr(Schema92.String),
-      lastLoginAt: Schema92.NullOr(Schema92.String),
-      loginCount: Schema92.Number,
-      lastError: Schema92.NullOr(Schema92.String),
-      lastErrorAt: Schema92.NullOr(Schema92.String),
-      createdAt: Schema92.String,
-      updatedAt: Schema92.NullOr(Schema92.String)
-    });
-    SAMLAuthLog = Schema92.Struct({
-      id: Schema92.String,
-      success: Schema92.Boolean,
-      errorCode: Schema92.NullOr(Schema92.String),
-      errorMessage: Schema92.NullOr(Schema92.String),
-      nameId: Schema92.NullOr(Schema92.String),
-      ipAddress: Schema92.NullOr(Schema92.String),
-      createdAt: Schema92.String
+      allowedDomains: Schema93.NullOr(Schema93.Array(Schema93.String)),
+      enforceSSO: Schema93.Boolean,
+      attributeMapping: Schema93.NullOr(SAMLAttributeMapping),
+      spEntityId: Schema93.NullOr(Schema93.String),
+      spAcsUrl: Schema93.NullOr(Schema93.String),
+      certificateExpiresAt: Schema93.NullOr(Schema93.String),
+      lastLoginAt: Schema93.NullOr(Schema93.String),
+      loginCount: Schema93.Number,
+      lastError: Schema93.NullOr(Schema93.String),
+      lastErrorAt: Schema93.NullOr(Schema93.String),
+      createdAt: Schema93.String,
+      updatedAt: Schema93.NullOr(Schema93.String)
     });
-    SAMLIdPTemplate = Schema92.Struct({
+    SAMLAuthLog = Schema93.Struct({
+      id: Schema93.String,
+      success: Schema93.Boolean,
+      errorCode: Schema93.NullOr(Schema93.String),
+      errorMessage: Schema93.NullOr(Schema93.String),
+      nameId: Schema93.NullOr(Schema93.String),
+      ipAddress: Schema93.NullOr(Schema93.String),
+      createdAt: Schema93.String
+    });
+    SAMLIdPTemplate = Schema93.Struct({
       type: SAMLProviderType,
-      name: Schema92.String,
-      instructions: Schema92.String,
-      requiredFields: Schema92.Array(Schema92.String)
-    });
-    SAMLNameIdFormatOption = Schema92.Struct({
-      key: Schema92.String,
-      value: Schema92.String,
-      description: Schema92.String
-    });
-    SAMLSignatureAlgorithmOption = Schema92.Struct({
-      key: Schema92.String,
-      value: Schema92.String,
-      recommended: Schema92.Boolean
-    });
-    GetSAMLProviderQuery = Schema92.Struct({
-      organizationId: Schema92.String
-    });
-    GetSAMLMetadataQuery = Schema92.Struct({
-      organizationId: Schema92.String
-    });
-    GetSAMLLogsQuery = Schema92.Struct({
-      providerId: Schema92.String,
-      limit: Schema92.optional(Schema92.String)
-    });
-    CreateSAMLProviderInput = Schema92.Struct({
-      organizationId: Schema92.String,
-      name: Schema92.String,
-      type: Schema92.optional(SAMLProviderType),
-      entityId: Schema92.String,
-      ssoUrl: Schema92.String,
-      sloUrl: Schema92.optional(Schema92.String),
-      certificate: Schema92.String,
-      nameIdFormat: Schema92.optional(SAMLNameIdFormat),
-      signatureAlgorithm: Schema92.optional(SAMLSignatureAlgorithm),
-      allowedDomains: Schema92.optional(Schema92.Array(Schema92.String)),
-      enforceSSO: Schema92.optional(Schema92.Boolean),
-      attributeMapping: Schema92.optional(SAMLAttributeMapping)
-    });
-    UpdateSAMLProviderInput = Schema92.Struct({
-      providerId: Schema92.String,
-      name: Schema92.optional(Schema92.String),
-      entityId: Schema92.optional(Schema92.String),
-      ssoUrl: Schema92.optional(Schema92.String),
-      sloUrl: Schema92.optional(Schema92.NullOr(Schema92.String)),
-      certificate: Schema92.optional(Schema92.String),
-      nameIdFormat: Schema92.optional(SAMLNameIdFormat),
-      signatureAlgorithm: Schema92.optional(SAMLSignatureAlgorithm),
-      allowedDomains: Schema92.optional(Schema92.Array(Schema92.String)),
-      enforceSSO: Schema92.optional(Schema92.Boolean),
-      attributeMapping: Schema92.optional(SAMLAttributeMapping)
-    });
-    SetSAMLProviderStatusInput = Schema92.Struct({
-      providerId: Schema92.String,
-      enabled: Schema92.Boolean
-    });
-    DeleteSAMLProviderInput = Schema92.Struct({
-      providerId: Schema92.String
-    });
-    TestSAMLConfigInput = Schema92.Struct({
-      entityId: Schema92.String,
-      ssoUrl: Schema92.String,
-      certificate: Schema92.String
-    });
-    GetSAMLProviderResult = Schema92.NullOr(SAMLProvider);
-    CreateSAMLProviderResult = Schema92.Struct({
-      id: Schema92.String,
-      spEntityId: Schema92.NullOr(Schema92.String),
-      spAcsUrl: Schema92.NullOr(Schema92.String)
+      name: Schema93.String,
+      instructions: Schema93.String,
+      requiredFields: Schema93.Array(Schema93.String)
+    });
+    SAMLNameIdFormatOption = Schema93.Struct({
+      key: Schema93.String,
+      value: Schema93.String,
+      description: Schema93.String
+    });
+    SAMLSignatureAlgorithmOption = Schema93.Struct({
+      key: Schema93.String,
+      value: Schema93.String,
+      recommended: Schema93.Boolean
+    });
+    GetSAMLProviderQuery = Schema93.Struct({
+      organizationId: Schema93.String
+    });
+    GetSAMLMetadataQuery = Schema93.Struct({
+      organizationId: Schema93.String
+    });
+    GetSAMLLogsQuery = Schema93.Struct({
+      providerId: Schema93.String,
+      limit: Schema93.optional(Schema93.String)
+    });
+    CreateSAMLProviderInput = Schema93.Struct({
+      organizationId: Schema93.String,
+      name: Schema93.String,
+      type: Schema93.optional(SAMLProviderType),
+      entityId: Schema93.String,
+      ssoUrl: Schema93.String,
+      sloUrl: Schema93.optional(Schema93.String),
+      certificate: Schema93.String,
+      nameIdFormat: Schema93.optional(SAMLNameIdFormat),
+      signatureAlgorithm: Schema93.optional(SAMLSignatureAlgorithm),
+      allowedDomains: Schema93.optional(Schema93.Array(Schema93.String)),
+      enforceSSO: Schema93.optional(Schema93.Boolean),
+      attributeMapping: Schema93.optional(SAMLAttributeMapping)
+    });
+    UpdateSAMLProviderInput = Schema93.Struct({
+      providerId: Schema93.String,
+      name: Schema93.optional(Schema93.String),
+      entityId: Schema93.optional(Schema93.String),
+      ssoUrl: Schema93.optional(Schema93.String),
+      sloUrl: Schema93.optional(Schema93.NullOr(Schema93.String)),
+      certificate: Schema93.optional(Schema93.String),
+      nameIdFormat: Schema93.optional(SAMLNameIdFormat),
+      signatureAlgorithm: Schema93.optional(SAMLSignatureAlgorithm),
+      allowedDomains: Schema93.optional(Schema93.Array(Schema93.String)),
+      enforceSSO: Schema93.optional(Schema93.Boolean),
+      attributeMapping: Schema93.optional(SAMLAttributeMapping)
+    });
+    SetSAMLProviderStatusInput = Schema93.Struct({
+      providerId: Schema93.String,
+      enabled: Schema93.Boolean
+    });
+    DeleteSAMLProviderInput = Schema93.Struct({
+      providerId: Schema93.String
+    });
+    TestSAMLConfigInput = Schema93.Struct({
+      entityId: Schema93.String,
+      ssoUrl: Schema93.String,
+      certificate: Schema93.String
+    });
+    GetSAMLProviderResult = Schema93.NullOr(SAMLProvider);
+    CreateSAMLProviderResult = Schema93.Struct({
+      id: Schema93.String,
+      spEntityId: Schema93.NullOr(Schema93.String),
+      spAcsUrl: Schema93.NullOr(Schema93.String)
     });
-    UpdateSAMLProviderResult = Schema92.Struct({
-      success: Schema92.Boolean
+    UpdateSAMLProviderResult = Schema93.Struct({
+      success: Schema93.Boolean
     });
-    SetSAMLProviderStatusResult = Schema92.Struct({
-      success: Schema92.Boolean
+    SetSAMLProviderStatusResult = Schema93.Struct({
+      success: Schema93.Boolean
     });
-    DeleteSAMLProviderResult = Schema92.Struct({
-      success: Schema92.Boolean
+    DeleteSAMLProviderResult = Schema93.Struct({
+      success: Schema93.Boolean
     });
-    GetSAMLMetadataResult = Schema92.Struct({
-      metadata: Schema92.String,
-      spEntityId: Schema92.NullOr(Schema92.String),
-      spAcsUrl: Schema92.NullOr(Schema92.String)
+    GetSAMLMetadataResult = Schema93.Struct({
+      metadata: Schema93.String,
+      spEntityId: Schema93.NullOr(Schema93.String),
+      spAcsUrl: Schema93.NullOr(Schema93.String)
     });
-    GetSAMLLogsResult = Schema92.Struct({
-      logs: Schema92.Array(SAMLAuthLog)
+    GetSAMLLogsResult = Schema93.Struct({
+      logs: Schema93.Array(SAMLAuthLog)
     });
-    TestSAMLConfigResult = Schema92.Struct({
-      valid: Schema92.Boolean,
-      issues: Schema92.Array(Schema92.String)
+    TestSAMLConfigResult = Schema93.Struct({
+      valid: Schema93.Boolean,
+      issues: Schema93.Array(Schema93.String)
     });
-    ListSAMLIdPTemplatesResult = Schema92.Struct({
-      templates: Schema92.Array(SAMLIdPTemplate)
+    ListSAMLIdPTemplatesResult = Schema93.Struct({
+      templates: Schema93.Array(SAMLIdPTemplate)
     });
-    ListSAMLNameIdFormatsResult = Schema92.Struct({
-      formats: Schema92.Array(SAMLNameIdFormatOption)
+    ListSAMLNameIdFormatsResult = Schema93.Struct({
+      formats: Schema93.Array(SAMLNameIdFormatOption)
     });
-    ListSAMLSignatureAlgorithmsResult = Schema92.Struct({
-      algorithms: Schema92.Array(SAMLSignatureAlgorithmOption)
+    ListSAMLSignatureAlgorithmsResult = Schema93.Struct({
+      algorithms: Schema93.Array(SAMLSignatureAlgorithmOption)
     });
   }
 });
@@ -11714,145 +11851,145 @@ var init_saml2 = __esm({
 });
 
 // ../contract/dist/schemas/search.js
-import { Schema as Schema93 } from "effect";
+import { Schema as Schema94 } from "effect";
 var SearchProjectIdParams, SearchAnalyticsQuery, SearchListDocumentsQuery, SearchStatsQuery, SearchTopQuery, SearchAnalyticsResult, SearchNamespaceStats, SearchStatsResult, SearchDocumentItem, SearchListDocumentsResult;
 var init_search = __esm({
   "../contract/dist/schemas/search.js"() {
     "use strict";
-    SearchProjectIdParams = Schema93.Struct({ projectId: Schema93.String });
-    SearchAnalyticsQuery = Schema93.Struct({
-      namespace: Schema93.optional(Schema93.String),
-      dateFrom: Schema93.optional(Schema93.String),
-      dateTo: Schema93.optional(Schema93.String)
-    });
-    SearchListDocumentsQuery = Schema93.Struct({
-      namespace: Schema93.optional(Schema93.String),
-      limit: Schema93.optional(Schema93.String),
-      offset: Schema93.optional(Schema93.String)
-    });
-    SearchStatsQuery = Schema93.Struct({ namespace: Schema93.optional(Schema93.String) });
-    SearchTopQuery = Schema93.Struct({ query: Schema93.String, count: Schema93.Number });
-    SearchAnalyticsResult = Schema93.Struct({
-      totalQueries: Schema93.Number,
-      avgLatencyMs: Schema93.Number,
-      clickThroughRate: Schema93.Number,
-      topQueries: Schema93.Array(SearchTopQuery)
-    });
-    SearchNamespaceStats = Schema93.Struct({
-      namespace: Schema93.String,
-      count: Schema93.Number
-    });
-    SearchStatsResult = Schema93.Struct({
-      totalDocuments: Schema93.Number,
-      documentsWithEmbedding: Schema93.Number,
-      byNamespace: Schema93.Array(SearchNamespaceStats)
-    });
-    SearchDocumentItem = Schema93.Struct({
-      id: Schema93.String,
-      namespace: Schema93.String,
-      externalId: Schema93.NullOr(Schema93.String),
-      title: Schema93.NullOr(Schema93.String),
-      contentPreview: Schema93.String,
-      url: Schema93.NullOr(Schema93.String),
-      category: Schema93.NullOr(Schema93.String),
-      type: Schema93.NullOr(Schema93.String),
-      tags: Schema93.NullOr(Schema93.Array(Schema93.String)),
-      hasEmbedding: Schema93.Boolean,
-      impressions: Schema93.Number,
-      clicks: Schema93.Number,
-      createdAt: Schema93.String,
-      updatedAt: Schema93.String
+    SearchProjectIdParams = Schema94.Struct({ projectId: Schema94.String });
+    SearchAnalyticsQuery = Schema94.Struct({
+      namespace: Schema94.optional(Schema94.String),
+      dateFrom: Schema94.optional(Schema94.String),
+      dateTo: Schema94.optional(Schema94.String)
+    });
+    SearchListDocumentsQuery = Schema94.Struct({
+      namespace: Schema94.optional(Schema94.String),
+      limit: Schema94.optional(Schema94.String),
+      offset: Schema94.optional(Schema94.String)
+    });
+    SearchStatsQuery = Schema94.Struct({ namespace: Schema94.optional(Schema94.String) });
+    SearchTopQuery = Schema94.Struct({ query: Schema94.String, count: Schema94.Number });
+    SearchAnalyticsResult = Schema94.Struct({
+      totalQueries: Schema94.Number,
+      avgLatencyMs: Schema94.Number,
+      clickThroughRate: Schema94.Number,
+      topQueries: Schema94.Array(SearchTopQuery)
+    });
+    SearchNamespaceStats = Schema94.Struct({
+      namespace: Schema94.String,
+      count: Schema94.Number
+    });
+    SearchStatsResult = Schema94.Struct({
+      totalDocuments: Schema94.Number,
+      documentsWithEmbedding: Schema94.Number,
+      byNamespace: Schema94.Array(SearchNamespaceStats)
+    });
+    SearchDocumentItem = Schema94.Struct({
+      id: Schema94.String,
+      namespace: Schema94.String,
+      externalId: Schema94.NullOr(Schema94.String),
+      title: Schema94.NullOr(Schema94.String),
+      contentPreview: Schema94.String,
+      url: Schema94.NullOr(Schema94.String),
+      category: Schema94.NullOr(Schema94.String),
+      type: Schema94.NullOr(Schema94.String),
+      tags: Schema94.NullOr(Schema94.Array(Schema94.String)),
+      hasEmbedding: Schema94.Boolean,
+      impressions: Schema94.Number,
+      clicks: Schema94.Number,
+      createdAt: Schema94.String,
+      updatedAt: Schema94.String
     });
-    SearchListDocumentsResult = Schema93.Struct({
-      documents: Schema93.Array(SearchDocumentItem),
-      total: Schema93.Number,
-      hasMore: Schema93.Boolean
+    SearchListDocumentsResult = Schema94.Struct({
+      documents: Schema94.Array(SearchDocumentItem),
+      total: Schema94.Number,
+      hasMore: Schema94.Boolean
     });
   }
 });
 
 // ../contract/dist/schemas/secret.js
-import { Schema as Schema94 } from "effect";
+import { Schema as Schema95 } from "effect";
 var SecretKey, SecretValue, EnvironmentRef2, SecretVersion, SecretListItem, SecretDetail, CreateSecretInput, CreateSecretResult, UpdateSecretInput, UpdateSecretResult, RollbackSecretInput, RollbackSecretResult;
 var init_secret = __esm({
   "../contract/dist/schemas/secret.js"() {
     "use strict";
     init_ids();
-    SecretKey = Schema94.String.pipe(Schema94.minLength(1), Schema94.maxLength(255), Schema94.pattern(/^[A-Z0-9_]+$/));
-    SecretValue = Schema94.String.pipe(Schema94.minLength(1), Schema94.maxLength(65536));
-    EnvironmentRef2 = Schema94.Struct({
+    SecretKey = Schema95.String.pipe(Schema95.minLength(1), Schema95.maxLength(255), Schema95.pattern(/^[A-Z0-9_]+$/));
+    SecretValue = Schema95.String.pipe(Schema95.minLength(1), Schema95.maxLength(65536));
+    EnvironmentRef2 = Schema95.Struct({
       id: EnvironmentId,
-      name: Schema94.String
+      name: Schema95.String
     });
-    SecretVersion = Schema94.Struct({
-      version: Schema94.String,
-      changeNote: Schema94.NullOr(Schema94.String),
-      createdAt: Schema94.String
+    SecretVersion = Schema95.Struct({
+      version: Schema95.String,
+      changeNote: Schema95.NullOr(Schema95.String),
+      createdAt: Schema95.String
     });
-    SecretListItem = Schema94.Struct({
+    SecretListItem = Schema95.Struct({
       id: SecretId,
       key: SecretKey,
-      description: Schema94.NullOr(Schema94.String),
-      environment: Schema94.NullOr(EnvironmentRef2),
-      isActive: Schema94.Boolean,
-      version: Schema94.String,
-      createdAt: Schema94.String,
-      updatedAt: Schema94.String
-    });
-    SecretDetail = Schema94.Struct({
+      description: Schema95.NullOr(Schema95.String),
+      environment: Schema95.NullOr(EnvironmentRef2),
+      isActive: Schema95.Boolean,
+      version: Schema95.String,
+      createdAt: Schema95.String,
+      updatedAt: Schema95.String
+    });
+    SecretDetail = Schema95.Struct({
       id: SecretId,
       key: SecretKey,
       /** Plaintext — only populated when `reveal=true` was requested. */
-      value: Schema94.NullOr(Schema94.String),
-      maskedValue: Schema94.String,
-      description: Schema94.NullOr(Schema94.String),
-      environment: Schema94.NullOr(EnvironmentRef2),
-      isActive: Schema94.Boolean,
-      version: Schema94.String,
-      versions: Schema94.Array(SecretVersion),
-      createdAt: Schema94.String,
-      updatedAt: Schema94.String
-    });
-    CreateSecretInput = Schema94.Struct({
+      value: Schema95.NullOr(Schema95.String),
+      maskedValue: Schema95.String,
+      description: Schema95.NullOr(Schema95.String),
+      environment: Schema95.NullOr(EnvironmentRef2),
+      isActive: Schema95.Boolean,
+      version: Schema95.String,
+      versions: Schema95.Array(SecretVersion),
+      createdAt: Schema95.String,
+      updatedAt: Schema95.String
+    });
+    CreateSecretInput = Schema95.Struct({
       projectId: ProjectId,
       key: SecretKey,
       value: SecretValue,
-      description: Schema94.optional(Schema94.String),
-      environmentId: Schema94.optional(EnvironmentId)
+      description: Schema95.optional(Schema95.String),
+      environmentId: Schema95.optional(EnvironmentId)
     });
-    CreateSecretResult = Schema94.Struct({
+    CreateSecretResult = Schema95.Struct({
       id: SecretId,
       key: SecretKey,
-      version: Schema94.String
+      version: Schema95.String
     });
-    UpdateSecretInput = Schema94.Struct({
+    UpdateSecretInput = Schema95.Struct({
       id: SecretId,
-      value: Schema94.optional(SecretValue),
-      description: Schema94.optional(Schema94.NullOr(Schema94.String)),
-      isActive: Schema94.optional(Schema94.Boolean),
-      changeNote: Schema94.optional(Schema94.String)
+      value: Schema95.optional(SecretValue),
+      description: Schema95.optional(Schema95.NullOr(Schema95.String)),
+      isActive: Schema95.optional(Schema95.Boolean),
+      changeNote: Schema95.optional(Schema95.String)
     });
-    UpdateSecretResult = Schema94.Struct({
+    UpdateSecretResult = Schema95.Struct({
       id: SecretId,
       key: SecretKey,
-      version: Schema94.String
+      version: Schema95.String
     });
-    RollbackSecretInput = Schema94.Struct({
+    RollbackSecretInput = Schema95.Struct({
       id: SecretId,
-      version: Schema94.String
+      version: Schema95.String
     });
-    RollbackSecretResult = Schema94.Struct({
+    RollbackSecretResult = Schema95.Struct({
       id: SecretId,
       key: SecretKey,
-      version: Schema94.String,
-      rolledBackFrom: Schema94.String,
-      rolledBackTo: Schema94.String
+      version: Schema95.String,
+      rolledBackFrom: Schema95.String,
+      rolledBackTo: Schema95.String
     });
   }
 });
 
 // ../contract/dist/endpoints/secrets.js
-import { Schema as Schema95 } from "effect";
+import { Schema as Schema96 } from "effect";
 var ListQuery, DetailQuery, StatsQuery, DeleteBody, secretsEndpoints;
 var init_secrets = __esm({
   "../contract/dist/endpoints/secrets.js"() {
@@ -11860,23 +11997,23 @@ var init_secrets = __esm({
     init_endpoint();
     init_ids();
     init_secret();
-    ListQuery = Schema95.Struct({
+    ListQuery = Schema96.Struct({
       projectId: ProjectId,
-      environmentId: Schema95.optional(EnvironmentId),
-      includeInactive: Schema95.optional(Schema95.String)
+      environmentId: Schema96.optional(EnvironmentId),
+      includeInactive: Schema96.optional(Schema96.String)
     });
-    DetailQuery = Schema95.Struct({
+    DetailQuery = Schema96.Struct({
       id: SecretId,
-      reveal: Schema95.optional(Schema95.String)
+      reveal: Schema96.optional(Schema96.String)
     });
-    StatsQuery = Schema95.Struct({ projectId: ProjectId });
-    DeleteBody = Schema95.Struct({ id: SecretId });
+    StatsQuery = Schema96.Struct({ projectId: ProjectId });
+    DeleteBody = Schema96.Struct({ id: SecretId });
     secretsEndpoints = {
       list: defineEndpoint({
         method: "GET",
         path: "/secrets",
         query: ListQuery,
-        response: Schema95.Struct({ secrets: Schema95.Array(SecretListItem) }),
+        response: Schema96.Struct({ secrets: Schema96.Array(SecretListItem) }),
         summary: "List secrets for a project (optionally scoped to an environment)",
         tags: ["secrets"]
       }),
@@ -11909,7 +12046,7 @@ var init_secrets = __esm({
         method: "DELETE",
         path: "/secrets",
         body: DeleteBody,
-        response: Schema95.Struct({ success: Schema95.Boolean }),
+        response: Schema96.Struct({ success: Schema96.Boolean }),
         summary: "Delete a secret",
         tags: ["secrets"]
       }),
@@ -11925,10 +12062,10 @@ var init_secrets = __esm({
         method: "GET",
         path: "/secrets/stats",
         query: StatsQuery,
-        response: Schema95.Struct({
-          stats: Schema95.Array(Schema95.Struct({
-            environmentId: Schema95.NullOr(Schema95.String),
-            count: Schema95.Number
+        response: Schema96.Struct({
+          stats: Schema96.Array(Schema96.Struct({
+            environmentId: Schema96.NullOr(Schema96.String),
+            count: Schema96.Number
           }))
         }),
         summary: "Per-environment secret counts",
@@ -11939,210 +12076,210 @@ var init_secrets = __esm({
 });
 
 // ../contract/dist/schemas/security.js
-import { Schema as Schema96 } from "effect";
+import { Schema as Schema97 } from "effect";
 var SecuritySuccessResult, TwoFactorSetupResult, TwoFactorVerifyInput, TwoFactorVerifyResult, TwoFactorDisableResult, TwoFactorStatusResult, BackupCodesViewResult, BackupCodesRegenerateResult, EmailChangeRequestInput, EmailChangeRequestResult, EmailChangeConfirmInput, EmailChangeConfirmResult, OAuthAccount, GetOAuthProvidersResult, OAuthConnectInput, OAuthConnectResult, OAuthDisconnectInput, OAuthDisconnectResult, PasswordStatusResult, SetPasswordInput, SetPasswordResult, Passkey, PasskeyListResult, PasskeyRegisterStartResult, AuthenticatorAttestationResponse, RegistrationResponse, PasskeyRegisterVerifyInput, PasskeyRenameInput, PasskeyRenameResult, PasskeyDeleteInput, PasskeyDeleteResult, SecuritySession, GetSessionsResult, RevokeSessionInput, RevokeSessionResult, RevokeOtherSessionsResult, RenameSessionInput, RenameSessionResult, SecurityFactor, SecurityRecommendation, SecurityScoreResult, SecurityStatusQuickResult, SecurityAlertType, SecurityAlert, GetSecurityAlertsQuery, GetSecurityAlertsResult, UnreadAlertCountResult, MarkAlertReadInput, MarkAlertReadResult, MarkAllAlertsReadResult;
 var init_security = __esm({
   "../contract/dist/schemas/security.js"() {
     "use strict";
-    SecuritySuccessResult = Schema96.Struct({
-      success: Schema96.Boolean
+    SecuritySuccessResult = Schema97.Struct({
+      success: Schema97.Boolean
     });
-    TwoFactorSetupResult = Schema96.Struct({
-      secret: Schema96.String,
-      uri: Schema96.String,
-      qrCode: Schema96.optional(Schema96.String)
+    TwoFactorSetupResult = Schema97.Struct({
+      secret: Schema97.String,
+      uri: Schema97.String,
+      qrCode: Schema97.optional(Schema97.String)
     });
-    TwoFactorVerifyInput = Schema96.Struct({
-      code: Schema96.String
+    TwoFactorVerifyInput = Schema97.Struct({
+      code: Schema97.String
     });
-    TwoFactorVerifyResult = Schema96.Struct({
-      success: Schema96.Boolean,
-      backupCodes: Schema96.Array(Schema96.String)
+    TwoFactorVerifyResult = Schema97.Struct({
+      success: Schema97.Boolean,
+      backupCodes: Schema97.Array(Schema97.String)
     });
     TwoFactorDisableResult = SecuritySuccessResult;
-    TwoFactorStatusResult = Schema96.Struct({
-      enabled: Schema96.Boolean,
-      backupCodesRemaining: Schema96.Number
+    TwoFactorStatusResult = Schema97.Struct({
+      enabled: Schema97.Boolean,
+      backupCodesRemaining: Schema97.Number
     });
-    BackupCodesViewResult = Schema96.Struct({
-      codes: Schema96.Array(Schema96.String),
-      remaining: Schema96.Number
+    BackupCodesViewResult = Schema97.Struct({
+      codes: Schema97.Array(Schema97.String),
+      remaining: Schema97.Number
     });
-    BackupCodesRegenerateResult = Schema96.Struct({
-      codes: Schema96.Array(Schema96.String)
+    BackupCodesRegenerateResult = Schema97.Struct({
+      codes: Schema97.Array(Schema97.String)
     });
-    EmailChangeRequestInput = Schema96.Struct({
-      newEmail: Schema96.String
+    EmailChangeRequestInput = Schema97.Struct({
+      newEmail: Schema97.String
     });
-    EmailChangeRequestResult = Schema96.Struct({
-      success: Schema96.Boolean,
-      message: Schema96.String,
-      expiresAt: Schema96.String
+    EmailChangeRequestResult = Schema97.Struct({
+      success: Schema97.Boolean,
+      message: Schema97.String,
+      expiresAt: Schema97.String
     });
-    EmailChangeConfirmInput = Schema96.Struct({
-      token: Schema96.String
+    EmailChangeConfirmInput = Schema97.Struct({
+      token: Schema97.String
     });
-    EmailChangeConfirmResult = Schema96.Struct({
-      success: Schema96.Boolean,
-      newEmail: Schema96.String
+    EmailChangeConfirmResult = Schema97.Struct({
+      success: Schema97.Boolean,
+      newEmail: Schema97.String
     });
-    OAuthAccount = Schema96.Struct({
-      provider: Schema96.String,
-      providerAccountId: Schema96.String,
-      email: Schema96.NullOr(Schema96.String),
-      connectedAt: Schema96.String
+    OAuthAccount = Schema97.Struct({
+      provider: Schema97.String,
+      providerAccountId: Schema97.String,
+      email: Schema97.NullOr(Schema97.String),
+      connectedAt: Schema97.String
     });
-    GetOAuthProvidersResult = Schema96.Struct({
-      providers: Schema96.Array(OAuthAccount)
+    GetOAuthProvidersResult = Schema97.Struct({
+      providers: Schema97.Array(OAuthAccount)
     });
-    OAuthConnectInput = Schema96.Struct({
-      provider: Schema96.String
+    OAuthConnectInput = Schema97.Struct({
+      provider: Schema97.String
     });
-    OAuthConnectResult = Schema96.Struct({
-      url: Schema96.String
+    OAuthConnectResult = Schema97.Struct({
+      url: Schema97.String
     });
-    OAuthDisconnectInput = Schema96.Struct({
-      provider: Schema96.String
+    OAuthDisconnectInput = Schema97.Struct({
+      provider: Schema97.String
     });
     OAuthDisconnectResult = SecuritySuccessResult;
-    PasswordStatusResult = Schema96.Struct({
-      hasPassword: Schema96.Boolean
+    PasswordStatusResult = Schema97.Struct({
+      hasPassword: Schema97.Boolean
     });
-    SetPasswordInput = Schema96.Struct({
-      password: Schema96.String
+    SetPasswordInput = Schema97.Struct({
+      password: Schema97.String
     });
     SetPasswordResult = SecuritySuccessResult;
-    Passkey = Schema96.Struct({
-      id: Schema96.String,
-      name: Schema96.NullOr(Schema96.String),
-      createdAt: Schema96.String,
-      lastUsedAt: Schema96.NullOr(Schema96.String)
-    });
-    PasskeyListResult = Schema96.Struct({
-      passkeys: Schema96.Array(Passkey)
-    });
-    PasskeyRegisterStartResult = Schema96.Struct({
-      challenge: Schema96.String,
-      rp: Schema96.Struct({
-        name: Schema96.String,
-        id: Schema96.String
-      }),
-      user: Schema96.Struct({
-        id: Schema96.String,
-        name: Schema96.String,
-        displayName: Schema96.String
-      }),
-      pubKeyCredParams: Schema96.Array(Schema96.Struct({
-        type: Schema96.Literal("public-key"),
-        alg: Schema96.Number
+    Passkey = Schema97.Struct({
+      id: Schema97.String,
+      name: Schema97.NullOr(Schema97.String),
+      createdAt: Schema97.String,
+      lastUsedAt: Schema97.NullOr(Schema97.String)
+    });
+    PasskeyListResult = Schema97.Struct({
+      passkeys: Schema97.Array(Passkey)
+    });
+    PasskeyRegisterStartResult = Schema97.Struct({
+      challenge: Schema97.String,
+      rp: Schema97.Struct({
+        name: Schema97.String,
+        id: Schema97.String
+      }),
+      user: Schema97.Struct({
+        id: Schema97.String,
+        name: Schema97.String,
+        displayName: Schema97.String
+      }),
+      pubKeyCredParams: Schema97.Array(Schema97.Struct({
+        type: Schema97.Literal("public-key"),
+        alg: Schema97.Number
       })),
-      timeout: Schema96.optional(Schema96.Number),
-      attestation: Schema96.optional(Schema96.String),
-      excludeCredentials: Schema96.optional(Schema96.Array(Schema96.Struct({
-        type: Schema96.Literal("public-key"),
-        id: Schema96.String,
-        transports: Schema96.optional(Schema96.Array(Schema96.String))
+      timeout: Schema97.optional(Schema97.Number),
+      attestation: Schema97.optional(Schema97.String),
+      excludeCredentials: Schema97.optional(Schema97.Array(Schema97.Struct({
+        type: Schema97.Literal("public-key"),
+        id: Schema97.String,
+        transports: Schema97.optional(Schema97.Array(Schema97.String))
       }))),
-      authenticatorSelection: Schema96.optional(Schema96.Struct({
-        authenticatorAttachment: Schema96.optional(Schema96.Literal("platform", "cross-platform")),
-        requireResidentKey: Schema96.optional(Schema96.Boolean),
-        residentKey: Schema96.optional(Schema96.Literal("discouraged", "preferred", "required")),
-        userVerification: Schema96.optional(Schema96.Literal("discouraged", "preferred", "required"))
+      authenticatorSelection: Schema97.optional(Schema97.Struct({
+        authenticatorAttachment: Schema97.optional(Schema97.Literal("platform", "cross-platform")),
+        requireResidentKey: Schema97.optional(Schema97.Boolean),
+        residentKey: Schema97.optional(Schema97.Literal("discouraged", "preferred", "required")),
+        userVerification: Schema97.optional(Schema97.Literal("discouraged", "preferred", "required"))
       }))
     });
-    AuthenticatorAttestationResponse = Schema96.Record({
-      key: Schema96.String,
-      value: Schema96.Unknown
+    AuthenticatorAttestationResponse = Schema97.Record({
+      key: Schema97.String,
+      value: Schema97.Unknown
     });
-    RegistrationResponse = Schema96.Record({
-      key: Schema96.String,
-      value: Schema96.Unknown
+    RegistrationResponse = Schema97.Record({
+      key: Schema97.String,
+      value: Schema97.Unknown
     });
-    PasskeyRegisterVerifyInput = Schema96.Struct({
-      credential: Schema96.Record({ key: Schema96.String, value: Schema96.Unknown }),
-      deviceName: Schema96.optional(Schema96.String)
+    PasskeyRegisterVerifyInput = Schema97.Struct({
+      credential: Schema97.Record({ key: Schema97.String, value: Schema97.Unknown }),
+      deviceName: Schema97.optional(Schema97.String)
     });
-    PasskeyRenameInput = Schema96.Struct({
-      passkeyId: Schema96.String,
-      name: Schema96.String
+    PasskeyRenameInput = Schema97.Struct({
+      passkeyId: Schema97.String,
+      name: Schema97.String
     });
     PasskeyRenameResult = SecuritySuccessResult;
-    PasskeyDeleteInput = Schema96.Struct({
-      passkeyId: Schema96.String
+    PasskeyDeleteInput = Schema97.Struct({
+      passkeyId: Schema97.String
     });
     PasskeyDeleteResult = SecuritySuccessResult;
-    SecuritySession = Schema96.Struct({
-      id: Schema96.String,
-      name: Schema96.NullOr(Schema96.String),
-      ipAddress: Schema96.NullOr(Schema96.String),
-      userAgent: Schema96.NullOr(Schema96.String),
-      createdAt: Schema96.String,
-      lastActiveAt: Schema96.NullOr(Schema96.String),
-      isCurrent: Schema96.Boolean
+    SecuritySession = Schema97.Struct({
+      id: Schema97.String,
+      name: Schema97.NullOr(Schema97.String),
+      ipAddress: Schema97.NullOr(Schema97.String),
+      userAgent: Schema97.NullOr(Schema97.String),
+      createdAt: Schema97.String,
+      lastActiveAt: Schema97.NullOr(Schema97.String),
+      isCurrent: Schema97.Boolean
     });
-    GetSessionsResult = Schema96.Struct({
-      sessions: Schema96.Array(SecuritySession)
+    GetSessionsResult = Schema97.Struct({
+      sessions: Schema97.Array(SecuritySession)
     });
-    RevokeSessionInput = Schema96.Struct({
-      sessionId: Schema96.String
+    RevokeSessionInput = Schema97.Struct({
+      sessionId: Schema97.String
     });
     RevokeSessionResult = SecuritySuccessResult;
-    RevokeOtherSessionsResult = Schema96.Struct({
-      revokedCount: Schema96.Number
+    RevokeOtherSessionsResult = Schema97.Struct({
+      revokedCount: Schema97.Number
     });
-    RenameSessionInput = Schema96.Struct({
-      sessionId: Schema96.String,
-      name: Schema96.String
+    RenameSessionInput = Schema97.Struct({
+      sessionId: Schema97.String,
+      name: Schema97.String
     });
     RenameSessionResult = SecuritySuccessResult;
-    SecurityFactor = Schema96.Struct({
-      name: Schema96.String,
-      enabled: Schema96.Boolean,
-      points: Schema96.Number,
-      maxPoints: Schema96.Number
-    });
-    SecurityRecommendation = Schema96.Struct({
-      id: Schema96.String,
-      title: Schema96.String,
-      description: Schema96.String,
-      priority: Schema96.Literal("low", "medium", "high"),
-      action: Schema96.String
-    });
-    SecurityScoreResult = Schema96.Struct({
-      score: Schema96.Number,
-      factors: Schema96.Array(SecurityFactor),
-      recommendations: Schema96.Array(SecurityRecommendation)
-    });
-    SecurityStatusQuickResult = Schema96.Struct({
-      score: Schema96.Number,
-      level: Schema96.Literal("low", "medium", "high", "excellent"),
-      hasPassword: Schema96.Boolean,
-      hasTwoFactor: Schema96.Boolean,
-      hasPasskeys: Schema96.Boolean,
-      sessionCount: Schema96.Number
-    });
-    SecurityAlertType = Schema96.Literal("password_changed", "email_changed", "two_factor_enabled", "two_factor_disabled", "new_device", "suspicious_login", "account_locked", "account_unlocked");
-    SecurityAlert = Schema96.Struct({
-      id: Schema96.String,
+    SecurityFactor = Schema97.Struct({
+      name: Schema97.String,
+      enabled: Schema97.Boolean,
+      points: Schema97.Number,
+      maxPoints: Schema97.Number
+    });
+    SecurityRecommendation = Schema97.Struct({
+      id: Schema97.String,
+      title: Schema97.String,
+      description: Schema97.String,
+      priority: Schema97.Literal("low", "medium", "high"),
+      action: Schema97.String
+    });
+    SecurityScoreResult = Schema97.Struct({
+      score: Schema97.Number,
+      factors: Schema97.Array(SecurityFactor),
+      recommendations: Schema97.Array(SecurityRecommendation)
+    });
+    SecurityStatusQuickResult = Schema97.Struct({
+      score: Schema97.Number,
+      level: Schema97.Literal("low", "medium", "high", "excellent"),
+      hasPassword: Schema97.Boolean,
+      hasTwoFactor: Schema97.Boolean,
+      hasPasskeys: Schema97.Boolean,
+      sessionCount: Schema97.Number
+    });
+    SecurityAlertType = Schema97.Literal("password_changed", "email_changed", "two_factor_enabled", "two_factor_disabled", "new_device", "suspicious_login", "account_locked", "account_unlocked");
+    SecurityAlert = Schema97.Struct({
+      id: Schema97.String,
       type: SecurityAlertType,
-      title: Schema96.String,
-      description: Schema96.NullOr(Schema96.String),
-      metadata: Schema96.NullOr(Schema96.Record({ key: Schema96.String, value: Schema96.Unknown })),
-      read: Schema96.Boolean,
-      createdAt: Schema96.String
+      title: Schema97.String,
+      description: Schema97.NullOr(Schema97.String),
+      metadata: Schema97.NullOr(Schema97.Record({ key: Schema97.String, value: Schema97.Unknown })),
+      read: Schema97.Boolean,
+      createdAt: Schema97.String
     });
-    GetSecurityAlertsQuery = Schema96.Struct({
-      limit: Schema96.optional(Schema96.String),
-      unreadOnly: Schema96.optional(Schema96.String)
+    GetSecurityAlertsQuery = Schema97.Struct({
+      limit: Schema97.optional(Schema97.String),
+      unreadOnly: Schema97.optional(Schema97.String)
     });
-    GetSecurityAlertsResult = Schema96.Struct({
-      alerts: Schema96.Array(SecurityAlert)
+    GetSecurityAlertsResult = Schema97.Struct({
+      alerts: Schema97.Array(SecurityAlert)
     });
-    UnreadAlertCountResult = Schema96.Struct({
-      count: Schema96.Number
+    UnreadAlertCountResult = Schema97.Struct({
+      count: Schema97.Number
     });
-    MarkAlertReadInput = Schema96.Struct({
-      alertId: Schema96.String
+    MarkAlertReadInput = Schema97.Struct({
+      alertId: Schema97.String
     });
     MarkAlertReadResult = SecuritySuccessResult;
     MarkAllAlertsReadResult = SecuritySuccessResult;
@@ -12423,364 +12560,383 @@ var init_security2 = __esm({
 });
 
 // ../contract/dist/schemas/service-tokens.js
-import { Schema as Schema97 } from "effect";
+import { Schema as Schema98 } from "effect";
 var ResourceScope, ServiceTokenView, ServiceTokenRequestView, OrgIdParams, OrgTokenIdParams, OrgRequestIdParams, ListServiceTokensQuery, CreateServiceTokenInput, SubmitServiceTokenRequestInput, DenyServiceTokenRequestInput, CreateServiceTokenResult, ListServiceTokensResult, GetServiceTokenResult, RevokeServiceTokenResult, RotateServiceTokenResult, ListServiceTokenRequestsResult, ServiceTokenRequestResult, MintServiceTokenRequestResult;
 var init_service_tokens = __esm({
   "../contract/dist/schemas/service-tokens.js"() {
     "use strict";
-    ResourceScope = Schema97.NullOr(Schema97.Struct({
-      orgId: Schema97.optional(Schema97.String),
-      projectId: Schema97.optional(Schema97.String),
-      envIds: Schema97.optional(Schema97.Array(Schema97.String))
+    ResourceScope = Schema98.NullOr(Schema98.Struct({
+      orgId: Schema98.optional(Schema98.String),
+      projectId: Schema98.optional(Schema98.String),
+      envIds: Schema98.optional(Schema98.Array(Schema98.String))
     }));
-    ServiceTokenView = Schema97.Struct({
-      id: Schema97.String,
-      orgId: Schema97.String,
-      name: Schema97.String,
-      tokenPrefix: Schema97.NullOr(Schema97.String),
-      projectId: Schema97.NullOr(Schema97.String),
-      environmentId: Schema97.NullOr(Schema97.String),
+    ServiceTokenView = Schema98.Struct({
+      id: Schema98.String,
+      orgId: Schema98.String,
+      name: Schema98.String,
+      tokenPrefix: Schema98.NullOr(Schema98.String),
+      projectId: Schema98.NullOr(Schema98.String),
+      environmentId: Schema98.NullOr(Schema98.String),
       resourceScope: ResourceScope,
-      scopes: Schema97.NullOr(Schema97.Array(Schema97.String)),
-      ipAllowlist: Schema97.NullOr(Schema97.Array(Schema97.String)),
-      createdBy: Schema97.NullOr(Schema97.String),
-      createdAt: Schema97.String,
-      expiresAt: Schema97.NullOr(Schema97.String),
-      lastUsedAt: Schema97.NullOr(Schema97.String),
-      revokedAt: Schema97.NullOr(Schema97.String),
-      revokedBy: Schema97.NullOr(Schema97.String),
-      useCount: Schema97.Number
+      scopes: Schema98.NullOr(Schema98.Array(Schema98.String)),
+      ipAllowlist: Schema98.NullOr(Schema98.Array(Schema98.String)),
+      createdBy: Schema98.NullOr(Schema98.String),
+      createdAt: Schema98.String,
+      expiresAt: Schema98.NullOr(Schema98.String),
+      lastUsedAt: Schema98.NullOr(Schema98.String),
+      revokedAt: Schema98.NullOr(Schema98.String),
+      revokedBy: Schema98.NullOr(Schema98.String),
+      useCount: Schema98.Number
     });
-    ServiceTokenRequestView = Schema97.Struct({
-      id: Schema97.String,
-      orgId: Schema97.String,
-      requestedBy: Schema97.String,
-      status: Schema97.Literal("pending", "approved", "denied", "minted", "cancelled"),
-      tokenName: Schema97.String,
-      scopes: Schema97.Array(Schema97.String),
-      projectId: Schema97.NullOr(Schema97.String),
-      environmentId: Schema97.NullOr(Schema97.String),
+    ServiceTokenRequestView = Schema98.Struct({
+      id: Schema98.String,
+      orgId: Schema98.String,
+      requestedBy: Schema98.String,
+      status: Schema98.Literal("pending", "approved", "denied", "minted", "cancelled"),
+      tokenName: Schema98.String,
+      scopes: Schema98.Array(Schema98.String),
+      projectId: Schema98.NullOr(Schema98.String),
+      environmentId: Schema98.NullOr(Schema98.String),
       resourceScope: ResourceScope,
-      ipAllowlist: Schema97.NullOr(Schema97.Array(Schema97.String)),
-      expiresInDays: Schema97.NullOr(Schema97.Number),
-      approvedBy: Schema97.NullOr(Schema97.String),
-      approvedAt: Schema97.NullOr(Schema97.String),
-      deniedReason: Schema97.NullOr(Schema97.String),
-      mintedTokenId: Schema97.NullOr(Schema97.String),
-      createdAt: Schema97.String,
-      updatedAt: Schema97.String
-    });
-    OrgIdParams = Schema97.Struct({ orgId: Schema97.String });
-    OrgTokenIdParams = Schema97.Struct({ orgId: Schema97.String, tokenId: Schema97.String });
-    OrgRequestIdParams = Schema97.Struct({ orgId: Schema97.String, id: Schema97.String });
-    ListServiceTokensQuery = Schema97.Struct({
-      includeRevoked: Schema97.optional(Schema97.Literal("true", "false"))
+      ipAllowlist: Schema98.NullOr(Schema98.Array(Schema98.String)),
+      expiresInDays: Schema98.NullOr(Schema98.Number),
+      approvedBy: Schema98.NullOr(Schema98.String),
+      approvedAt: Schema98.NullOr(Schema98.String),
+      deniedReason: Schema98.NullOr(Schema98.String),
+      mintedTokenId: Schema98.NullOr(Schema98.String),
+      createdAt: Schema98.String,
+      updatedAt: Schema98.String
     });
-    CreateServiceTokenInput = Schema97.Struct({
-      name: Schema97.String,
-      scopes: Schema97.Array(Schema97.String),
-      projectId: Schema97.optional(Schema97.NullOr(Schema97.String)),
-      environmentId: Schema97.optional(Schema97.NullOr(Schema97.String)),
-      resourceScope: Schema97.optional(ResourceScope),
-      ipAllowlist: Schema97.optional(Schema97.NullOr(Schema97.Array(Schema97.String))),
-      expiresInDays: Schema97.optional(Schema97.NullOr(Schema97.Number))
-    });
-    SubmitServiceTokenRequestInput = Schema97.Struct({
-      name: Schema97.String,
-      scopes: Schema97.Array(Schema97.String),
-      projectId: Schema97.optional(Schema97.NullOr(Schema97.String)),
-      environmentId: Schema97.optional(Schema97.NullOr(Schema97.String)),
-      resourceScope: Schema97.optional(ResourceScope),
-      ipAllowlist: Schema97.optional(Schema97.NullOr(Schema97.Array(Schema97.String))),
-      expiresInDays: Schema97.optional(Schema97.NullOr(Schema97.Number))
-    });
-    DenyServiceTokenRequestInput = Schema97.Struct({ reason: Schema97.String });
-    CreateServiceTokenResult = Schema97.Struct({
-      token: Schema97.String,
+    OrgIdParams = Schema98.Struct({ orgId: Schema98.String });
+    OrgTokenIdParams = Schema98.Struct({ orgId: Schema98.String, tokenId: Schema98.String });
+    OrgRequestIdParams = Schema98.Struct({ orgId: Schema98.String, id: Schema98.String });
+    ListServiceTokensQuery = Schema98.Struct({
+      includeRevoked: Schema98.optional(Schema98.Literal("true", "false"))
+    });
+    CreateServiceTokenInput = Schema98.Struct({
+      name: Schema98.String,
+      scopes: Schema98.Array(Schema98.String),
+      projectId: Schema98.optional(Schema98.NullOr(Schema98.String)),
+      environmentId: Schema98.optional(Schema98.NullOr(Schema98.String)),
+      resourceScope: Schema98.optional(ResourceScope),
+      ipAllowlist: Schema98.optional(Schema98.NullOr(Schema98.Array(Schema98.String))),
+      expiresInDays: Schema98.optional(Schema98.NullOr(Schema98.Number))
+    });
+    SubmitServiceTokenRequestInput = Schema98.Struct({
+      name: Schema98.String,
+      scopes: Schema98.Array(Schema98.String),
+      projectId: Schema98.optional(Schema98.NullOr(Schema98.String)),
+      environmentId: Schema98.optional(Schema98.NullOr(Schema98.String)),
+      resourceScope: Schema98.optional(ResourceScope),
+      ipAllowlist: Schema98.optional(Schema98.NullOr(Schema98.Array(Schema98.String))),
+      expiresInDays: Schema98.optional(Schema98.NullOr(Schema98.Number))
+    });
+    DenyServiceTokenRequestInput = Schema98.Struct({ reason: Schema98.String });
+    CreateServiceTokenResult = Schema98.Struct({
+      token: Schema98.String,
       view: ServiceTokenView
     });
-    ListServiceTokensResult = Schema97.Struct({ tokens: Schema97.Array(ServiceTokenView) });
-    GetServiceTokenResult = Schema97.Struct({ view: ServiceTokenView });
-    RevokeServiceTokenResult = Schema97.Struct({ view: ServiceTokenView });
-    RotateServiceTokenResult = Schema97.Struct({
-      token: Schema97.String,
+    ListServiceTokensResult = Schema98.Struct({ tokens: Schema98.Array(ServiceTokenView) });
+    GetServiceTokenResult = Schema98.Struct({ view: ServiceTokenView });
+    RevokeServiceTokenResult = Schema98.Struct({ view: ServiceTokenView });
+    RotateServiceTokenResult = Schema98.Struct({
+      token: Schema98.String,
       oldView: ServiceTokenView,
       newView: ServiceTokenView
     });
-    ListServiceTokenRequestsResult = Schema97.Struct({
-      requests: Schema97.Array(ServiceTokenRequestView)
+    ListServiceTokenRequestsResult = Schema98.Struct({
+      requests: Schema98.Array(ServiceTokenRequestView)
     });
-    ServiceTokenRequestResult = Schema97.Struct({ request: ServiceTokenRequestView });
-    MintServiceTokenRequestResult = Schema97.Struct({
-      token: Schema97.String,
+    ServiceTokenRequestResult = Schema98.Struct({ request: ServiceTokenRequestView });
+    MintServiceTokenRequestResult = Schema98.Struct({
+      token: Schema98.String,
       request: ServiceTokenRequestView
     });
   }
 });
 
 // ../contract/dist/schemas/session-replay.js
-import { Schema as Schema98 } from "effect";
+import { Schema as Schema99 } from "effect";
 var SessionMarker, RageClick, DeadClick, NetworkRequest, ConsoleLog, SessionReplaySummary, SessionReplayFull, ListSessionsQuery2, ListSessionsResult, SessionStatsResult, DeleteSessionResult;
 var init_session_replay = __esm({
   "../contract/dist/schemas/session-replay.js"() {
     "use strict";
-    SessionMarker = Schema98.Struct({
-      type: Schema98.String,
-      timestamp: Schema98.Number,
-      payload: Schema98.optional(Schema98.Record({ key: Schema98.String, value: Schema98.Unknown }))
-    });
-    RageClick = Schema98.Struct({
-      timestamp: Schema98.Number,
-      element: Schema98.String,
-      selector: Schema98.optional(Schema98.String),
-      clickCount: Schema98.Number,
-      duration: Schema98.optional(Schema98.Number),
-      x: Schema98.optional(Schema98.Number),
-      y: Schema98.optional(Schema98.Number)
-    });
-    DeadClick = Schema98.Struct({
-      timestamp: Schema98.Number,
-      element: Schema98.String,
-      selector: Schema98.optional(Schema98.String),
-      expectedAction: Schema98.optional(Schema98.String),
-      x: Schema98.optional(Schema98.Number),
-      y: Schema98.optional(Schema98.Number),
-      waitTime: Schema98.optional(Schema98.Number)
-    });
-    NetworkRequest = Schema98.Struct({
-      timestamp: Schema98.Number,
-      method: Schema98.String,
-      url: Schema98.String,
-      status: Schema98.Number,
-      duration: Schema98.Number
-    });
-    ConsoleLog = Schema98.Struct({
-      timestamp: Schema98.Number,
-      level: Schema98.Literal("log", "info", "warn", "error"),
-      message: Schema98.String,
-      stack: Schema98.optional(Schema98.String)
-    });
-    SessionReplaySummary = Schema98.Struct({
-      id: Schema98.String,
-      sessionId: Schema98.String,
-      userId: Schema98.NullOr(Schema98.String),
-      url: Schema98.NullOr(Schema98.String),
-      userAgent: Schema98.NullOr(Schema98.String),
-      screenWidth: Schema98.NullOr(Schema98.Number),
-      screenHeight: Schema98.NullOr(Schema98.Number),
-      devicePixelRatio: Schema98.NullOr(Schema98.Number),
-      timezone: Schema98.NullOr(Schema98.String),
-      language: Schema98.NullOr(Schema98.String),
-      duration: Schema98.NullOr(Schema98.Number),
-      eventCount: Schema98.Number,
-      bytesStored: Schema98.Number,
-      hasErrors: Schema98.Boolean,
-      errorIds: Schema98.Array(Schema98.String),
-      hasRageClicks: Schema98.Boolean,
-      hasDeadClicks: Schema98.Boolean,
-      rageClickCount: Schema98.Number,
-      deadClickCount: Schema98.Number,
-      networkRequestCount: Schema98.Number,
-      consoleLogCount: Schema98.Number,
-      markers: Schema98.Array(SessionMarker),
-      isComplete: Schema98.Boolean,
-      startedAt: Schema98.String,
-      endedAt: Schema98.NullOr(Schema98.String),
-      createdAt: Schema98.String,
-      updatedAt: Schema98.String
-    });
-    SessionReplayFull = Schema98.Struct({
-      id: Schema98.String,
-      sessionId: Schema98.String,
-      userId: Schema98.NullOr(Schema98.String),
-      url: Schema98.NullOr(Schema98.String),
-      userAgent: Schema98.NullOr(Schema98.String),
-      screenWidth: Schema98.NullOr(Schema98.Number),
-      screenHeight: Schema98.NullOr(Schema98.Number),
-      devicePixelRatio: Schema98.NullOr(Schema98.Number),
-      timezone: Schema98.NullOr(Schema98.String),
-      language: Schema98.NullOr(Schema98.String),
-      duration: Schema98.NullOr(Schema98.Number),
-      eventCount: Schema98.Number,
-      bytesStored: Schema98.Number,
-      hasErrors: Schema98.Boolean,
-      errorIds: Schema98.Array(Schema98.String),
-      hasRageClicks: Schema98.Boolean,
-      hasDeadClicks: Schema98.Boolean,
-      rageClickCount: Schema98.Number,
-      deadClickCount: Schema98.Number,
-      networkRequestCount: Schema98.Number,
-      consoleLogCount: Schema98.Number,
-      markers: Schema98.Array(SessionMarker),
-      isComplete: Schema98.Boolean,
-      startedAt: Schema98.String,
-      endedAt: Schema98.NullOr(Schema98.String),
-      createdAt: Schema98.String,
-      updatedAt: Schema98.String,
-      events: Schema98.Array(Schema98.Record({ key: Schema98.String, value: Schema98.Unknown })),
-      rageClicks: Schema98.Array(RageClick),
-      deadClicks: Schema98.Array(DeadClick),
-      networkRequests: Schema98.Array(NetworkRequest),
-      consoleLogs: Schema98.Array(ConsoleLog)
-    });
-    ListSessionsQuery2 = Schema98.Struct({
-      hasErrors: Schema98.optional(Schema98.String),
-      hasRageClicks: Schema98.optional(Schema98.String),
-      hasDeadClicks: Schema98.optional(Schema98.String),
-      userId: Schema98.optional(Schema98.String),
-      startDate: Schema98.optional(Schema98.String),
-      endDate: Schema98.optional(Schema98.String),
-      limit: Schema98.optional(Schema98.String),
-      offset: Schema98.optional(Schema98.String)
-    });
-    ListSessionsResult = Schema98.Struct({
-      sessions: Schema98.Array(SessionReplaySummary),
-      total: Schema98.Number,
-      hasMore: Schema98.Boolean
-    });
-    SessionStatsResult = Schema98.Struct({
-      totalSessions: Schema98.Number,
-      sessionsThisMonth: Schema98.Number,
-      sessionsThisWeek: Schema98.Number,
-      sessionsWithErrors: Schema98.Number,
-      sessionsWithRageClicks: Schema98.Number,
-      totalStorageBytes: Schema98.Number
-    });
-    DeleteSessionResult = Schema98.Struct({
-      success: Schema98.Boolean
+    SessionMarker = Schema99.Struct({
+      type: Schema99.String,
+      timestamp: Schema99.Number,
+      payload: Schema99.optional(Schema99.Record({ key: Schema99.String, value: Schema99.Unknown }))
+    });
+    RageClick = Schema99.Struct({
+      timestamp: Schema99.Number,
+      element: Schema99.String,
+      selector: Schema99.optional(Schema99.String),
+      clickCount: Schema99.Number,
+      duration: Schema99.optional(Schema99.Number),
+      x: Schema99.optional(Schema99.Number),
+      y: Schema99.optional(Schema99.Number)
+    });
+    DeadClick = Schema99.Struct({
+      timestamp: Schema99.Number,
+      element: Schema99.String,
+      selector: Schema99.optional(Schema99.String),
+      expectedAction: Schema99.optional(Schema99.String),
+      x: Schema99.optional(Schema99.Number),
+      y: Schema99.optional(Schema99.Number),
+      waitTime: Schema99.optional(Schema99.Number)
+    });
+    NetworkRequest = Schema99.Struct({
+      timestamp: Schema99.Number,
+      method: Schema99.String,
+      url: Schema99.String,
+      status: Schema99.Number,
+      duration: Schema99.Number
+    });
+    ConsoleLog = Schema99.Struct({
+      timestamp: Schema99.Number,
+      level: Schema99.Literal("log", "info", "warn", "error"),
+      message: Schema99.String,
+      stack: Schema99.optional(Schema99.String)
+    });
+    SessionReplaySummary = Schema99.Struct({
+      id: Schema99.String,
+      sessionId: Schema99.String,
+      userId: Schema99.NullOr(Schema99.String),
+      url: Schema99.NullOr(Schema99.String),
+      userAgent: Schema99.NullOr(Schema99.String),
+      screenWidth: Schema99.NullOr(Schema99.Number),
+      screenHeight: Schema99.NullOr(Schema99.Number),
+      devicePixelRatio: Schema99.NullOr(Schema99.Number),
+      timezone: Schema99.NullOr(Schema99.String),
+      language: Schema99.NullOr(Schema99.String),
+      duration: Schema99.NullOr(Schema99.Number),
+      eventCount: Schema99.Number,
+      bytesStored: Schema99.Number,
+      hasErrors: Schema99.Boolean,
+      errorIds: Schema99.Array(Schema99.String),
+      hasRageClicks: Schema99.Boolean,
+      hasDeadClicks: Schema99.Boolean,
+      rageClickCount: Schema99.Number,
+      deadClickCount: Schema99.Number,
+      networkRequestCount: Schema99.Number,
+      consoleLogCount: Schema99.Number,
+      markers: Schema99.Array(SessionMarker),
+      isComplete: Schema99.Boolean,
+      startedAt: Schema99.String,
+      endedAt: Schema99.NullOr(Schema99.String),
+      createdAt: Schema99.String,
+      updatedAt: Schema99.String
+    });
+    SessionReplayFull = Schema99.Struct({
+      id: Schema99.String,
+      sessionId: Schema99.String,
+      userId: Schema99.NullOr(Schema99.String),
+      url: Schema99.NullOr(Schema99.String),
+      userAgent: Schema99.NullOr(Schema99.String),
+      screenWidth: Schema99.NullOr(Schema99.Number),
+      screenHeight: Schema99.NullOr(Schema99.Number),
+      devicePixelRatio: Schema99.NullOr(Schema99.Number),
+      timezone: Schema99.NullOr(Schema99.String),
+      language: Schema99.NullOr(Schema99.String),
+      duration: Schema99.NullOr(Schema99.Number),
+      eventCount: Schema99.Number,
+      bytesStored: Schema99.Number,
+      hasErrors: Schema99.Boolean,
+      errorIds: Schema99.Array(Schema99.String),
+      hasRageClicks: Schema99.Boolean,
+      hasDeadClicks: Schema99.Boolean,
+      rageClickCount: Schema99.Number,
+      deadClickCount: Schema99.Number,
+      networkRequestCount: Schema99.Number,
+      consoleLogCount: Schema99.Number,
+      markers: Schema99.Array(SessionMarker),
+      isComplete: Schema99.Boolean,
+      startedAt: Schema99.String,
+      endedAt: Schema99.NullOr(Schema99.String),
+      createdAt: Schema99.String,
+      updatedAt: Schema99.String,
+      events: Schema99.Array(Schema99.Record({ key: Schema99.String, value: Schema99.Unknown })),
+      rageClicks: Schema99.Array(RageClick),
+      deadClicks: Schema99.Array(DeadClick),
+      networkRequests: Schema99.Array(NetworkRequest),
+      consoleLogs: Schema99.Array(ConsoleLog)
+    });
+    ListSessionsQuery2 = Schema99.Struct({
+      hasErrors: Schema99.optional(Schema99.String),
+      hasRageClicks: Schema99.optional(Schema99.String),
+      hasDeadClicks: Schema99.optional(Schema99.String),
+      userId: Schema99.optional(Schema99.String),
+      startDate: Schema99.optional(Schema99.String),
+      endDate: Schema99.optional(Schema99.String),
+      limit: Schema99.optional(Schema99.String),
+      offset: Schema99.optional(Schema99.String)
+    });
+    ListSessionsResult = Schema99.Struct({
+      sessions: Schema99.Array(SessionReplaySummary),
+      total: Schema99.Number,
+      hasMore: Schema99.Boolean
+    });
+    SessionStatsResult = Schema99.Struct({
+      totalSessions: Schema99.Number,
+      sessionsThisMonth: Schema99.Number,
+      sessionsThisWeek: Schema99.Number,
+      sessionsWithErrors: Schema99.Number,
+      sessionsWithRageClicks: Schema99.Number,
+      totalStorageBytes: Schema99.Number
+    });
+    DeleteSessionResult = Schema99.Struct({
+      success: Schema99.Boolean
     });
   }
 });
 
 // ../contract/dist/schemas/storage.js
-import { Schema as Schema99 } from "effect";
-var FileId, UploadId, FileVersionId, FileVisibility, SignedUrlDisposition, UploadMethod, File, FileVersion, UploadCreateRequest, UploadPart, UploadCreateSinglePartResult, UploadCreateMultipartResult, UploadCreateResult, UploadPartPresignResult, UploadCompletePart, UploadCompleteRequest, UploadCompleteResult, ListFilesQuery, ListFilesResult, SoftDeleteFileResult, SignedUrlRequest, SignedUrlResult, CopyFileRequest, ListFileVersionsResult, RestoreVersionResult;
+import { Schema as Schema100 } from "effect";
+var FileId, UploadId, FileVersionId, FileVisibility, SignedUrlDisposition, UploadMethod, File, FileVersion, UploadCreateRequest, UploadPart, UploadCreateSinglePartResult, UploadCreateMultipartResult, UploadCreateResult, UploadPartPresignResult, UploadCompletePart, UploadCompleteRequest, UploadCompleteResult, ListFilesQuery, ListFilesResult, SoftDeleteFileResult, StorageTakedownReason, TakedownFileRequest, StorageTakedownRecord, TakedownFileResult, SignedUrlRequest, SignedUrlResult, CopyFileRequest, ListFileVersionsResult, RestoreVersionResult;
 var init_storage = __esm({
   "../contract/dist/schemas/storage.js"() {
     "use strict";
-    FileId = Schema99.String.pipe(Schema99.brand("FileId"));
-    UploadId = Schema99.String.pipe(Schema99.brand("UploadId"));
-    FileVersionId = Schema99.String.pipe(Schema99.brand("FileVersionId"));
-    FileVisibility = Schema99.Literal("public", "private");
-    SignedUrlDisposition = Schema99.Literal("attachment", "inline");
-    UploadMethod = Schema99.Literal("PUT", "MULTIPART");
-    File = Schema99.Struct({
+    FileId = Schema100.String.pipe(Schema100.brand("FileId"));
+    UploadId = Schema100.String.pipe(Schema100.brand("UploadId"));
+    FileVersionId = Schema100.String.pipe(Schema100.brand("FileVersionId"));
+    FileVisibility = Schema100.Literal("public", "private");
+    SignedUrlDisposition = Schema100.Literal("attachment", "inline");
+    UploadMethod = Schema100.Literal("PUT", "MULTIPART");
+    File = Schema100.Struct({
       id: FileId,
-      filename: Schema99.String,
-      contentType: Schema99.String,
-      size: Schema99.Number,
-      checksumSha256: Schema99.String,
-      etag: Schema99.String,
+      filename: Schema100.String,
+      contentType: Schema100.String,
+      size: Schema100.Number,
+      checksumSha256: Schema100.String,
+      etag: Schema100.String,
       visibility: FileVisibility,
-      folder: Schema99.NullOr(Schema99.String),
-      metadata: Schema99.Record({ key: Schema99.String, value: Schema99.Unknown }),
+      folder: Schema100.NullOr(Schema100.String),
+      metadata: Schema100.Record({ key: Schema100.String, value: Schema100.Unknown }),
       /** Public URL when `visibility === 'public'`; `null` otherwise. Use `:signedUrl` for private files. */
-      url: Schema99.NullOr(Schema99.String),
-      isDeleted: Schema99.Boolean,
-      createdAt: Schema99.DateFromString,
-      updatedAt: Schema99.DateFromString
+      url: Schema100.NullOr(Schema100.String),
+      isDeleted: Schema100.Boolean,
+      createdAt: Schema100.DateFromString,
+      updatedAt: Schema100.DateFromString
     });
-    FileVersion = Schema99.Struct({
+    FileVersion = Schema100.Struct({
       id: FileVersionId,
       fileId: FileId,
-      versionNumber: Schema99.Number,
-      size: Schema99.Number,
-      contentType: Schema99.String,
-      checksumSha256: Schema99.String,
-      etag: Schema99.String,
-      createdAt: Schema99.DateFromString,
-      createdBy: Schema99.NullOr(Schema99.String),
-      isCurrent: Schema99.Boolean
-    });
-    UploadCreateRequest = Schema99.Struct({
-      filename: Schema99.String.pipe(Schema99.minLength(1)),
-      contentType: Schema99.String.pipe(Schema99.minLength(1)),
-      size: Schema99.Number.pipe(Schema99.greaterThanOrEqualTo(0)),
-      folder: Schema99.optional(Schema99.String),
-      visibility: Schema99.optional(FileVisibility),
-      metadata: Schema99.optional(Schema99.Record({ key: Schema99.String, value: Schema99.Unknown })),
+      versionNumber: Schema100.Number,
+      size: Schema100.Number,
+      contentType: Schema100.String,
+      checksumSha256: Schema100.String,
+      etag: Schema100.String,
+      createdAt: Schema100.DateFromString,
+      createdBy: Schema100.NullOr(Schema100.String),
+      isCurrent: Schema100.Boolean
+    });
+    UploadCreateRequest = Schema100.Struct({
+      filename: Schema100.String.pipe(Schema100.minLength(1)),
+      contentType: Schema100.String.pipe(Schema100.minLength(1)),
+      size: Schema100.Number.pipe(Schema100.greaterThanOrEqualTo(0)),
+      folder: Schema100.optional(Schema100.String),
+      visibility: Schema100.optional(FileVisibility),
+      metadata: Schema100.optional(Schema100.Record({ key: Schema100.String, value: Schema100.Unknown })),
       /** Pre-computed SHA-256 (hex); verified server-side on `:complete` (multipart) or after PUT (single). */
-      checksumSha256: Schema99.optional(Schema99.String),
+      checksumSha256: Schema100.optional(Schema100.String),
       /** S3-style precondition; if `'*'`, fail when a file already exists at (folder, filename). */
-      ifNoneMatch: Schema99.optional(Schema99.Literal("*"))
+      ifNoneMatch: Schema100.optional(Schema100.Literal("*"))
     });
-    UploadPart = Schema99.Struct({
-      partNumber: Schema99.Number.pipe(Schema99.greaterThanOrEqualTo(1)),
-      url: Schema99.String,
-      expiresAt: Schema99.DateFromString
+    UploadPart = Schema100.Struct({
+      partNumber: Schema100.Number.pipe(Schema100.greaterThanOrEqualTo(1)),
+      url: Schema100.String,
+      expiresAt: Schema100.DateFromString
     });
-    UploadCreateSinglePartResult = Schema99.Struct({
-      method: Schema99.Literal("PUT"),
+    UploadCreateSinglePartResult = Schema100.Struct({
+      method: Schema100.Literal("PUT"),
       uploadId: UploadId,
       fileId: FileId,
-      url: Schema99.String,
-      headers: Schema99.Record({ key: Schema99.String, value: Schema99.String }),
-      expiresAt: Schema99.DateFromString
+      url: Schema100.String,
+      headers: Schema100.Record({ key: Schema100.String, value: Schema100.String }),
+      expiresAt: Schema100.DateFromString
     });
-    UploadCreateMultipartResult = Schema99.Struct({
-      method: Schema99.Literal("MULTIPART"),
+    UploadCreateMultipartResult = Schema100.Struct({
+      method: Schema100.Literal("MULTIPART"),
       uploadId: UploadId,
       fileId: FileId,
-      partSize: Schema99.Number,
-      partCount: Schema99.Number,
-      parts: Schema99.Array(UploadPart),
-      expiresAt: Schema99.DateFromString
+      partSize: Schema100.Number,
+      partCount: Schema100.Number,
+      parts: Schema100.Array(UploadPart),
+      expiresAt: Schema100.DateFromString
     });
-    UploadCreateResult = Schema99.Union(UploadCreateSinglePartResult, UploadCreateMultipartResult);
-    UploadPartPresignResult = Schema99.Struct({
-      url: Schema99.String,
-      expiresAt: Schema99.DateFromString
+    UploadCreateResult = Schema100.Union(UploadCreateSinglePartResult, UploadCreateMultipartResult);
+    UploadPartPresignResult = Schema100.Struct({
+      url: Schema100.String,
+      expiresAt: Schema100.DateFromString
     });
-    UploadCompletePart = Schema99.Struct({
-      partNumber: Schema99.Number.pipe(Schema99.greaterThanOrEqualTo(1)),
-      etag: Schema99.String.pipe(Schema99.minLength(1))
+    UploadCompletePart = Schema100.Struct({
+      partNumber: Schema100.Number.pipe(Schema100.greaterThanOrEqualTo(1)),
+      etag: Schema100.String.pipe(Schema100.minLength(1))
     });
-    UploadCompleteRequest = Schema99.Struct({
-      parts: Schema99.Array(UploadCompletePart)
+    UploadCompleteRequest = Schema100.Struct({
+      parts: Schema100.Array(UploadCompletePart)
     });
-    UploadCompleteResult = Schema99.Struct({
+    UploadCompleteResult = Schema100.Struct({
       fileId: FileId,
-      url: Schema99.NullOr(Schema99.String),
-      size: Schema99.Number,
-      etag: Schema99.String,
-      checksumSha256: Schema99.String
+      url: Schema100.NullOr(Schema100.String),
+      size: Schema100.Number,
+      etag: Schema100.String,
+      checksumSha256: Schema100.String
     });
-    ListFilesQuery = Schema99.Struct({
-      folder: Schema99.optional(Schema99.String),
-      cursor: Schema99.optional(Schema99.String),
+    ListFilesQuery = Schema100.Struct({
+      folder: Schema100.optional(Schema100.String),
+      cursor: Schema100.optional(Schema100.String),
       /** Page size; clamped server-side to [1, 100]; default 25. */
-      limit: Schema99.optional(Schema99.Number),
-      includeDeleted: Schema99.optional(Schema99.Boolean)
+      limit: Schema100.optional(Schema100.Number),
+      includeDeleted: Schema100.optional(Schema100.Boolean)
     });
-    ListFilesResult = Schema99.Struct({
-      files: Schema99.Array(File),
-      nextCursor: Schema99.NullOr(Schema99.String)
+    ListFilesResult = Schema100.Struct({
+      files: Schema100.Array(File),
+      nextCursor: Schema100.NullOr(Schema100.String)
     });
-    SoftDeleteFileResult = Schema99.Struct({
+    SoftDeleteFileResult = Schema100.Struct({
       id: FileId,
-      isDeleted: Schema99.Literal(true)
+      isDeleted: Schema100.Literal(true)
+    });
+    StorageTakedownReason = Schema100.Literal("dmca", "malware", "abuse", "legal");
+    TakedownFileRequest = Schema100.Struct({
+      reason: StorageTakedownReason,
+      noticeId: Schema100.optional(Schema100.String),
+      source: Schema100.optional(Schema100.String),
+      description: Schema100.optional(Schema100.String)
+    });
+    StorageTakedownRecord = Schema100.Struct({
+      reason: StorageTakedownReason,
+      noticeId: Schema100.NullOr(Schema100.String),
+      source: Schema100.NullOr(Schema100.String),
+      description: Schema100.NullOr(Schema100.String),
+      actedAt: Schema100.DateFromString
+    });
+    TakedownFileResult = Schema100.Struct({
+      id: FileId,
+      isDeleted: Schema100.Literal(true),
+      takedown: StorageTakedownRecord
     });
-    SignedUrlRequest = Schema99.Struct({
-      expiresIn: Schema99.optional(Schema99.Number.pipe(Schema99.greaterThanOrEqualTo(1))),
-      disposition: Schema99.optional(SignedUrlDisposition),
+    SignedUrlRequest = Schema100.Struct({
+      expiresIn: Schema100.optional(Schema100.Number.pipe(Schema100.greaterThanOrEqualTo(1))),
+      disposition: Schema100.optional(SignedUrlDisposition),
       /** Restrict the signed URL to a specific authenticated user (claim baked into the signature). */
-      userId: Schema99.optional(Schema99.String)
+      userId: Schema100.optional(Schema100.String)
     });
-    SignedUrlResult = Schema99.Struct({
-      url: Schema99.String,
-      expiresAt: Schema99.DateFromString,
+    SignedUrlResult = Schema100.Struct({
+      url: Schema100.String,
+      expiresAt: Schema100.DateFromString,
       file: File
     });
-    CopyFileRequest = Schema99.Struct({
-      folder: Schema99.optional(Schema99.String),
-      filename: Schema99.optional(Schema99.String),
-      visibility: Schema99.optional(FileVisibility),
-      metadata: Schema99.optional(Schema99.Record({ key: Schema99.String, value: Schema99.Unknown }))
+    CopyFileRequest = Schema100.Struct({
+      folder: Schema100.optional(Schema100.String),
+      filename: Schema100.optional(Schema100.String),
+      visibility: Schema100.optional(FileVisibility),
+      metadata: Schema100.optional(Schema100.Record({ key: Schema100.String, value: Schema100.Unknown }))
     });
-    ListFileVersionsResult = Schema99.Struct({
-      versions: Schema99.Array(FileVersion)
+    ListFileVersionsResult = Schema100.Struct({
+      versions: Schema100.Array(FileVersion)
     });
-    RestoreVersionResult = Schema99.Struct({
+    RestoreVersionResult = Schema100.Struct({
       file: File,
       version: FileVersion
     });
@@ -12788,295 +12944,295 @@ var init_storage = __esm({
 });
 
 // ../contract/dist/schemas/storage-admin.js
-import { Schema as Schema100 } from "effect";
+import { Schema as Schema101 } from "effect";
 var StorageProjectIdParams, StorageProjectBucketParams, StorageProjectFileParams, StorageQuery, BucketAccessRuleType, BucketAccessPermission, BucketAccessRule, StorageProjectRef, StorageBucket, StorageBucketMinimal, BucketFile, StorageFile, StorageFolderInfo, CreateBucketInput, UpdateBucketInput, DeleteBucketInput, BulkDeleteBucketsInput, ListBucketsResult, GetBucketResult, DeleteBucketResult, BulkDeleteBucketsResult, ListBucketFilesResult, ListStorageFilesResult, StorageUploadByDay, StorageUploadByType, StorageRecentFile, StorageServiceDataResult, StorageAdminResult;
 var init_storage_admin = __esm({
   "../contract/dist/schemas/storage-admin.js"() {
     "use strict";
-    StorageProjectIdParams = Schema100.Struct({ id: Schema100.String });
-    StorageProjectBucketParams = Schema100.Struct({
-      projectId: Schema100.String,
-      bucketId: Schema100.String
-    });
-    StorageProjectFileParams = Schema100.Struct({
-      projectId: Schema100.String,
-      fileId: Schema100.String
-    });
-    StorageQuery = Schema100.Struct({
-      limit: Schema100.optional(Schema100.String),
-      offset: Schema100.optional(Schema100.String),
-      prefix: Schema100.optional(Schema100.String),
-      cursor: Schema100.optional(Schema100.String),
-      path: Schema100.optional(Schema100.String),
-      search: Schema100.optional(Schema100.String)
+    StorageProjectIdParams = Schema101.Struct({ id: Schema101.String });
+    StorageProjectBucketParams = Schema101.Struct({
+      projectId: Schema101.String,
+      bucketId: Schema101.String
     });
-    BucketAccessRuleType = Schema100.Literal("public", "authenticated", "owner_only", "admin_only");
-    BucketAccessPermission = Schema100.Literal("read", "read-write", "full");
-    BucketAccessRule = Schema100.Struct({
+    StorageProjectFileParams = Schema101.Struct({
+      projectId: Schema101.String,
+      fileId: Schema101.String
+    });
+    StorageQuery = Schema101.Struct({
+      limit: Schema101.optional(Schema101.String),
+      offset: Schema101.optional(Schema101.String),
+      prefix: Schema101.optional(Schema101.String),
+      cursor: Schema101.optional(Schema101.String),
+      path: Schema101.optional(Schema101.String),
+      search: Schema101.optional(Schema101.String)
+    });
+    BucketAccessRuleType = Schema101.Literal("public", "authenticated", "owner_only", "admin_only");
+    BucketAccessPermission = Schema101.Literal("read", "read-write", "full");
+    BucketAccessRule = Schema101.Struct({
       type: BucketAccessRuleType,
       permission: BucketAccessPermission
     });
-    StorageProjectRef = Schema100.Struct({
-      id: Schema100.String,
-      name: Schema100.String,
-      slug: Schema100.String
+    StorageProjectRef = Schema101.Struct({
+      id: Schema101.String,
+      name: Schema101.String,
+      slug: Schema101.String
     });
-    StorageBucket = Schema100.Struct({
-      id: Schema100.String,
-      name: Schema100.String,
-      description: Schema100.NullOr(Schema100.String),
-      isPublic: Schema100.Boolean,
-      fileCount: Schema100.Number,
-      totalSize: Schema100.Number,
-      createdAt: Schema100.String,
-      updatedAt: Schema100.String,
-      accessRules: Schema100.Array(BucketAccessRule),
-      corsEnabled: Schema100.Boolean,
-      allowedOrigins: Schema100.Array(Schema100.String),
-      maxFileSize: Schema100.Number,
-      allowedMimeTypes: Schema100.Array(Schema100.String)
-    });
-    StorageBucketMinimal = Schema100.Struct({
-      id: Schema100.String,
-      name: Schema100.String,
-      description: Schema100.NullOr(Schema100.String),
-      isPublic: Schema100.Boolean,
-      createdAt: Schema100.String,
-      updatedAt: Schema100.String,
-      accessRules: Schema100.Array(BucketAccessRule),
-      corsEnabled: Schema100.Boolean,
-      allowedOrigins: Schema100.Array(Schema100.String),
-      maxFileSize: Schema100.Number,
-      allowedMimeTypes: Schema100.Array(Schema100.String)
-    });
-    BucketFile = Schema100.Struct({
-      id: Schema100.String,
-      filename: Schema100.String,
-      path: Schema100.String,
-      url: Schema100.NullOr(Schema100.String),
-      mimeType: Schema100.String,
-      size: Schema100.Number,
-      formattedSize: Schema100.String,
-      createdAt: Schema100.String
-    });
-    StorageFile = Schema100.Struct({
-      id: Schema100.String,
-      name: Schema100.String,
-      path: Schema100.String,
-      mimeType: Schema100.String,
-      size: Schema100.Number,
-      url: Schema100.String,
-      thumbnailUrl: Schema100.NullOr(Schema100.String),
-      createdAt: Schema100.String
-    });
-    StorageFolderInfo = Schema100.Struct({
-      name: Schema100.String,
-      fileCount: Schema100.Number,
-      totalSize: Schema100.Number
-    });
-    CreateBucketInput = Schema100.Struct({
-      projectId: Schema100.String,
-      environmentId: Schema100.optional(Schema100.String),
-      name: Schema100.String,
-      description: Schema100.optional(Schema100.String),
-      isPublic: Schema100.optional(Schema100.Boolean),
-      accessRules: Schema100.optional(Schema100.Array(BucketAccessRule)),
-      corsEnabled: Schema100.optional(Schema100.Boolean),
-      allowedOrigins: Schema100.optional(Schema100.Array(Schema100.String)),
-      maxFileSize: Schema100.optional(Schema100.Number),
-      allowedMimeTypes: Schema100.optional(Schema100.Array(Schema100.String))
-    });
-    UpdateBucketInput = Schema100.Struct({
-      name: Schema100.optional(Schema100.String),
-      description: Schema100.optional(Schema100.NullOr(Schema100.String)),
-      isPublic: Schema100.optional(Schema100.Boolean),
-      accessRules: Schema100.optional(Schema100.Array(BucketAccessRule)),
-      corsEnabled: Schema100.optional(Schema100.Boolean),
-      allowedOrigins: Schema100.optional(Schema100.Array(Schema100.String)),
-      maxFileSize: Schema100.optional(Schema100.Number),
-      allowedMimeTypes: Schema100.optional(Schema100.Array(Schema100.String))
-    });
-    DeleteBucketInput = Schema100.Struct({
-      force: Schema100.optional(Schema100.Boolean)
-    });
-    BulkDeleteBucketsInput = Schema100.Struct({
-      projectId: Schema100.String,
-      bucketIds: Schema100.Array(Schema100.String)
-    });
-    ListBucketsResult = Schema100.Struct({
+    StorageBucket = Schema101.Struct({
+      id: Schema101.String,
+      name: Schema101.String,
+      description: Schema101.NullOr(Schema101.String),
+      isPublic: Schema101.Boolean,
+      fileCount: Schema101.Number,
+      totalSize: Schema101.Number,
+      createdAt: Schema101.String,
+      updatedAt: Schema101.String,
+      accessRules: Schema101.Array(BucketAccessRule),
+      corsEnabled: Schema101.Boolean,
+      allowedOrigins: Schema101.Array(Schema101.String),
+      maxFileSize: Schema101.Number,
+      allowedMimeTypes: Schema101.Array(Schema101.String)
+    });
+    StorageBucketMinimal = Schema101.Struct({
+      id: Schema101.String,
+      name: Schema101.String,
+      description: Schema101.NullOr(Schema101.String),
+      isPublic: Schema101.Boolean,
+      createdAt: Schema101.String,
+      updatedAt: Schema101.String,
+      accessRules: Schema101.Array(BucketAccessRule),
+      corsEnabled: Schema101.Boolean,
+      allowedOrigins: Schema101.Array(Schema101.String),
+      maxFileSize: Schema101.Number,
+      allowedMimeTypes: Schema101.Array(Schema101.String)
+    });
+    BucketFile = Schema101.Struct({
+      id: Schema101.String,
+      filename: Schema101.String,
+      path: Schema101.String,
+      url: Schema101.NullOr(Schema101.String),
+      mimeType: Schema101.String,
+      size: Schema101.Number,
+      formattedSize: Schema101.String,
+      createdAt: Schema101.String
+    });
+    StorageFile = Schema101.Struct({
+      id: Schema101.String,
+      name: Schema101.String,
+      path: Schema101.String,
+      mimeType: Schema101.String,
+      size: Schema101.Number,
+      url: Schema101.String,
+      thumbnailUrl: Schema101.NullOr(Schema101.String),
+      createdAt: Schema101.String
+    });
+    StorageFolderInfo = Schema101.Struct({
+      name: Schema101.String,
+      fileCount: Schema101.Number,
+      totalSize: Schema101.Number
+    });
+    CreateBucketInput = Schema101.Struct({
+      projectId: Schema101.String,
+      environmentId: Schema101.optional(Schema101.String),
+      name: Schema101.String,
+      description: Schema101.optional(Schema101.String),
+      isPublic: Schema101.optional(Schema101.Boolean),
+      accessRules: Schema101.optional(Schema101.Array(BucketAccessRule)),
+      corsEnabled: Schema101.optional(Schema101.Boolean),
+      allowedOrigins: Schema101.optional(Schema101.Array(Schema101.String)),
+      maxFileSize: Schema101.optional(Schema101.Number),
+      allowedMimeTypes: Schema101.optional(Schema101.Array(Schema101.String))
+    });
+    UpdateBucketInput = Schema101.Struct({
+      name: Schema101.optional(Schema101.String),
+      description: Schema101.optional(Schema101.NullOr(Schema101.String)),
+      isPublic: Schema101.optional(Schema101.Boolean),
+      accessRules: Schema101.optional(Schema101.Array(BucketAccessRule)),
+      corsEnabled: Schema101.optional(Schema101.Boolean),
+      allowedOrigins: Schema101.optional(Schema101.Array(Schema101.String)),
+      maxFileSize: Schema101.optional(Schema101.Number),
+      allowedMimeTypes: Schema101.optional(Schema101.Array(Schema101.String))
+    });
+    DeleteBucketInput = Schema101.Struct({
+      force: Schema101.optional(Schema101.Boolean)
+    });
+    BulkDeleteBucketsInput = Schema101.Struct({
+      projectId: Schema101.String,
+      bucketIds: Schema101.Array(Schema101.String)
+    });
+    ListBucketsResult = Schema101.Struct({
       app: StorageProjectRef,
-      buckets: Schema100.Array(StorageBucket),
-      total: Schema100.Number
-    });
-    GetBucketResult = Schema100.extend(StorageBucket, Schema100.Struct({ formattedSize: Schema100.String }));
-    DeleteBucketResult = Schema100.Struct({
-      success: Schema100.Boolean,
-      filesDeleted: Schema100.Number
-    });
-    BulkDeleteBucketsResult = Schema100.Struct({
-      deleted: Schema100.Number,
-      filesDeleted: Schema100.Number,
-      errors: Schema100.optional(Schema100.Array(Schema100.Struct({
-        id: Schema100.String,
-        error: Schema100.String
+      buckets: Schema101.Array(StorageBucket),
+      total: Schema101.Number
+    });
+    GetBucketResult = Schema101.extend(StorageBucket, Schema101.Struct({ formattedSize: Schema101.String }));
+    DeleteBucketResult = Schema101.Struct({
+      success: Schema101.Boolean,
+      filesDeleted: Schema101.Number
+    });
+    BulkDeleteBucketsResult = Schema101.Struct({
+      deleted: Schema101.Number,
+      filesDeleted: Schema101.Number,
+      errors: Schema101.optional(Schema101.Array(Schema101.Struct({
+        id: Schema101.String,
+        error: Schema101.String
       })))
     });
-    ListBucketFilesResult = Schema100.Struct({
-      files: Schema100.Array(BucketFile),
-      total: Schema100.Number,
-      bucket: Schema100.Struct({
-        id: Schema100.String,
-        name: Schema100.String
+    ListBucketFilesResult = Schema101.Struct({
+      files: Schema101.Array(BucketFile),
+      total: Schema101.Number,
+      bucket: Schema101.Struct({
+        id: Schema101.String,
+        name: Schema101.String
       })
     });
-    ListStorageFilesResult = Schema100.Struct({
+    ListStorageFilesResult = Schema101.Struct({
       app: StorageProjectRef,
-      files: Schema100.Array(StorageFile),
-      folders: Schema100.Array(StorageFolderInfo),
-      total: Schema100.Number,
-      limit: Schema100.Number,
-      offset: Schema100.Number
-    });
-    StorageUploadByDay = Schema100.Struct({
-      date: Schema100.String,
-      count: Schema100.Number,
-      bytes: Schema100.Number
-    });
-    StorageUploadByType = Schema100.Struct({
-      mimeType: Schema100.String,
-      count: Schema100.Number,
-      bytes: Schema100.Number
-    });
-    StorageRecentFile = Schema100.Struct({
-      id: Schema100.String,
-      filename: Schema100.String,
-      mimeType: Schema100.String,
-      sizeBytes: Schema100.Number,
-      createdAt: Schema100.String
+      files: Schema101.Array(StorageFile),
+      folders: Schema101.Array(StorageFolderInfo),
+      total: Schema101.Number,
+      limit: Schema101.Number,
+      offset: Schema101.Number
     });
-    StorageServiceDataResult = Schema100.Struct({
+    StorageUploadByDay = Schema101.Struct({
+      date: Schema101.String,
+      count: Schema101.Number,
+      bytes: Schema101.Number
+    });
+    StorageUploadByType = Schema101.Struct({
+      mimeType: Schema101.String,
+      count: Schema101.Number,
+      bytes: Schema101.Number
+    });
+    StorageRecentFile = Schema101.Struct({
+      id: Schema101.String,
+      filename: Schema101.String,
+      mimeType: Schema101.String,
+      sizeBytes: Schema101.Number,
+      createdAt: Schema101.String
+    });
+    StorageServiceDataResult = Schema101.Struct({
       app: StorageProjectRef,
-      totalStats: Schema100.Struct({
-        files: Schema100.Number,
-        totalBytes: Schema100.Number
+      totalStats: Schema101.Struct({
+        files: Schema101.Number,
+        totalBytes: Schema101.Number
       }),
-      uploadsByDay: Schema100.Array(StorageUploadByDay),
-      uploadsByType: Schema100.Array(StorageUploadByType),
-      recentFiles: Schema100.Array(StorageRecentFile),
-      uploadsThisMonth: Schema100.Number
+      uploadsByDay: Schema101.Array(StorageUploadByDay),
+      uploadsByType: Schema101.Array(StorageUploadByType),
+      recentFiles: Schema101.Array(StorageRecentFile),
+      uploadsThisMonth: Schema101.Number
     });
-    StorageAdminResult = Schema100.Unknown;
+    StorageAdminResult = Schema101.Unknown;
   }
 });
 
 // ../contract/dist/schemas/tasks.js
-import { Schema as Schema101 } from "effect";
+import { Schema as Schema102 } from "effect";
 var TaskStatusEnum, TaskTypeEnum, TaskHttpMethod, Task, TaskIdParam, ScheduleIdParam, TasksProjectIdQuery, ListTasksQuery, ScheduleTaskInput, CreateCronTaskInput, CancelTaskInput, CronActionInput, DeleteCronInput, TasksStatusResult, ListTasksResult, GetTaskResult, ScheduleTaskResult, CreateCronTaskResult, CancelTaskResult, CronActionResult;
 var init_tasks = __esm({
   "../contract/dist/schemas/tasks.js"() {
     "use strict";
-    TaskStatusEnum = Schema101.Literal("pending", "queued", "running", "completed", "failed", "scheduled", "paused", "cancelled", "deleted");
-    TaskTypeEnum = Schema101.Literal("one-time", "cron");
-    TaskHttpMethod = Schema101.Literal("GET", "POST", "PUT", "DELETE", "PATCH");
-    Task = Schema101.Struct({
-      id: Schema101.String,
-      name: Schema101.NullOr(Schema101.String),
+    TaskStatusEnum = Schema102.Literal("pending", "queued", "running", "completed", "failed", "scheduled", "paused", "cancelled", "deleted");
+    TaskTypeEnum = Schema102.Literal("one-time", "cron");
+    TaskHttpMethod = Schema102.Literal("GET", "POST", "PUT", "DELETE", "PATCH");
+    Task = Schema102.Struct({
+      id: Schema102.String,
+      name: Schema102.NullOr(Schema102.String),
       type: TaskTypeEnum,
       status: TaskStatusEnum,
-      callbackUrl: Schema101.String,
-      payload: Schema101.NullOr(Schema101.Record({ key: Schema101.String, value: Schema101.Unknown })),
-      method: Schema101.NullOr(TaskHttpMethod),
-      headers: Schema101.NullOr(Schema101.Record({ key: Schema101.String, value: Schema101.String })),
-      scheduledFor: Schema101.NullOr(Schema101.String),
-      startedAt: Schema101.NullOr(Schema101.String),
-      completedAt: Schema101.NullOr(Schema101.String),
-      failedAt: Schema101.NullOr(Schema101.String),
-      cronExpression: Schema101.NullOr(Schema101.String),
-      retries: Schema101.Number,
-      maxRetries: Schema101.Number,
-      lastError: Schema101.NullOr(Schema101.String),
-      qstashMessageId: Schema101.NullOr(Schema101.String),
-      qstashScheduleId: Schema101.NullOr(Schema101.String),
-      createdAt: Schema101.String
-    });
-    TaskIdParam = Schema101.Struct({ jobId: Schema101.String });
-    ScheduleIdParam = Schema101.Struct({ scheduleId: Schema101.String });
-    TasksProjectIdQuery = Schema101.Struct({ projectId: Schema101.String });
-    ListTasksQuery = Schema101.Struct({
-      projectId: Schema101.String,
-      status: Schema101.optional(Schema101.Literal("all", "pending", "queued", "running", "completed", "failed", "scheduled", "paused", "cancelled", "deleted")),
-      type: Schema101.optional(Schema101.Literal("all", "one-time", "cron")),
-      limit: Schema101.optional(Schema101.String),
-      offset: Schema101.optional(Schema101.String)
-    });
-    ScheduleTaskInput = Schema101.Struct({
-      projectId: Schema101.String,
-      environmentId: Schema101.optional(Schema101.String),
-      callbackUrl: Schema101.String,
-      payload: Schema101.optional(Schema101.Record({ key: Schema101.String, value: Schema101.Unknown })),
-      method: Schema101.optional(TaskHttpMethod),
-      headers: Schema101.optional(Schema101.Record({ key: Schema101.String, value: Schema101.String })),
-      delay: Schema101.optional(Schema101.Number),
-      scheduledFor: Schema101.optional(Schema101.String),
-      retries: Schema101.optional(Schema101.Number),
-      name: Schema101.optional(Schema101.String),
-      type: Schema101.optional(Schema101.String),
-      timeout: Schema101.optional(Schema101.Number)
-    });
-    CreateCronTaskInput = Schema101.Struct({
-      projectId: Schema101.String,
-      callbackUrl: Schema101.String,
-      cron: Schema101.String,
-      payload: Schema101.optional(Schema101.Record({ key: Schema101.String, value: Schema101.Unknown })),
-      method: Schema101.optional(TaskHttpMethod),
-      headers: Schema101.optional(Schema101.Record({ key: Schema101.String, value: Schema101.String })),
-      retries: Schema101.optional(Schema101.Number),
-      name: Schema101.String,
-      type: Schema101.optional(Schema101.String),
-      paused: Schema101.optional(Schema101.Boolean),
-      environmentId: Schema101.optional(Schema101.String),
-      taskName: Schema101.optional(Schema101.String),
-      handlerPath: Schema101.optional(Schema101.String)
-    });
-    CancelTaskInput = Schema101.Struct({ projectId: Schema101.String });
-    CronActionInput = Schema101.Struct({ projectId: Schema101.String });
-    DeleteCronInput = Schema101.Struct({ projectId: Schema101.String });
-    TasksStatusResult = Schema101.Struct({
-      available: Schema101.Boolean,
-      provider: Schema101.String
-    });
-    ListTasksResult = Schema101.Struct({
-      jobs: Schema101.Array(Task),
-      total: Schema101.Number,
-      limit: Schema101.Number,
-      offset: Schema101.Number
-    });
-    GetTaskResult = Schema101.Struct({ job: Task });
-    ScheduleTaskResult = Schema101.Struct({
-      jobId: Schema101.String,
-      messageId: Schema101.optional(Schema101.String),
-      scheduledFor: Schema101.NullOr(Schema101.String)
-    });
-    CreateCronTaskResult = Schema101.Struct({
-      jobId: Schema101.String,
-      scheduleId: Schema101.String,
-      cron: Schema101.String,
-      paused: Schema101.Boolean
-    });
-    CancelTaskResult = Schema101.Struct({ success: Schema101.Boolean });
-    CronActionResult = Schema101.Struct({ success: Schema101.Boolean });
+      callbackUrl: Schema102.String,
+      payload: Schema102.NullOr(Schema102.Record({ key: Schema102.String, value: Schema102.Unknown })),
+      method: Schema102.NullOr(TaskHttpMethod),
+      headers: Schema102.NullOr(Schema102.Record({ key: Schema102.String, value: Schema102.String })),
+      scheduledFor: Schema102.NullOr(Schema102.String),
+      startedAt: Schema102.NullOr(Schema102.String),
+      completedAt: Schema102.NullOr(Schema102.String),
+      failedAt: Schema102.NullOr(Schema102.String),
+      cronExpression: Schema102.NullOr(Schema102.String),
+      retries: Schema102.Number,
+      maxRetries: Schema102.Number,
+      lastError: Schema102.NullOr(Schema102.String),
+      qstashMessageId: Schema102.NullOr(Schema102.String),
+      qstashScheduleId: Schema102.NullOr(Schema102.String),
+      createdAt: Schema102.String
+    });
+    TaskIdParam = Schema102.Struct({ jobId: Schema102.String });
+    ScheduleIdParam = Schema102.Struct({ scheduleId: Schema102.String });
+    TasksProjectIdQuery = Schema102.Struct({ projectId: Schema102.String });
+    ListTasksQuery = Schema102.Struct({
+      projectId: Schema102.String,
+      status: Schema102.optional(Schema102.Literal("all", "pending", "queued", "running", "completed", "failed", "scheduled", "paused", "cancelled", "deleted")),
+      type: Schema102.optional(Schema102.Literal("all", "one-time", "cron")),
+      limit: Schema102.optional(Schema102.String),
+      offset: Schema102.optional(Schema102.String)
+    });
+    ScheduleTaskInput = Schema102.Struct({
+      projectId: Schema102.String,
+      environmentId: Schema102.optional(Schema102.String),
+      callbackUrl: Schema102.String,
+      payload: Schema102.optional(Schema102.Record({ key: Schema102.String, value: Schema102.Unknown })),
+      method: Schema102.optional(TaskHttpMethod),
+      headers: Schema102.optional(Schema102.Record({ key: Schema102.String, value: Schema102.String })),
+      delay: Schema102.optional(Schema102.Number),
+      scheduledFor: Schema102.optional(Schema102.String),
+      retries: Schema102.optional(Schema102.Number),
+      name: Schema102.optional(Schema102.String),
+      type: Schema102.optional(Schema102.String),
+      timeout: Schema102.optional(Schema102.Number)
+    });
+    CreateCronTaskInput = Schema102.Struct({
+      projectId: Schema102.String,
+      callbackUrl: Schema102.String,
+      cron: Schema102.String,
+      payload: Schema102.optional(Schema102.Record({ key: Schema102.String, value: Schema102.Unknown })),
+      method: Schema102.optional(TaskHttpMethod),
+      headers: Schema102.optional(Schema102.Record({ key: Schema102.String, value: Schema102.String })),
+      retries: Schema102.optional(Schema102.Number),
+      name: Schema102.String,
+      type: Schema102.optional(Schema102.String),
+      paused: Schema102.optional(Schema102.Boolean),
+      environmentId: Schema102.optional(Schema102.String),
+      taskName: Schema102.optional(Schema102.String),
+      handlerPath: Schema102.optional(Schema102.String)
+    });
+    CancelTaskInput = Schema102.Struct({ projectId: Schema102.String });
+    CronActionInput = Schema102.Struct({ projectId: Schema102.String });
+    DeleteCronInput = Schema102.Struct({ projectId: Schema102.String });
+    TasksStatusResult = Schema102.Struct({
+      available: Schema102.Boolean,
+      provider: Schema102.String
+    });
+    ListTasksResult = Schema102.Struct({
+      jobs: Schema102.Array(Task),
+      total: Schema102.Number,
+      limit: Schema102.Number,
+      offset: Schema102.Number
+    });
+    GetTaskResult = Schema102.Struct({ job: Task });
+    ScheduleTaskResult = Schema102.Struct({
+      jobId: Schema102.String,
+      messageId: Schema102.optional(Schema102.String),
+      scheduledFor: Schema102.NullOr(Schema102.String)
+    });
+    CreateCronTaskResult = Schema102.Struct({
+      jobId: Schema102.String,
+      scheduleId: Schema102.String,
+      cron: Schema102.String,
+      paused: Schema102.Boolean
+    });
+    CancelTaskResult = Schema102.Struct({ success: Schema102.Boolean });
+    CronActionResult = Schema102.Struct({ success: Schema102.Boolean });
   }
 });
 
 // ../contract/dist/endpoints/users.js
-import { Schema as Schema102 } from "effect";
+import { Schema as Schema103 } from "effect";
 var SessionIdPath, usersEndpoints;
 var init_users = __esm({
   "../contract/dist/endpoints/users.js"() {
     "use strict";
     init_endpoint();
     init_user();
-    SessionIdPath = Schema102.Struct({ sessionId: Schema102.String });
+    SessionIdPath = Schema103.Struct({ sessionId: Schema103.String });
     usersEndpoints = {
       whoami: defineEndpoint({
         method: "GET",
@@ -13111,28 +13267,28 @@ var init_users = __esm({
         method: "POST",
         path: "/user/password",
         body: ChangePasswordInput,
-        response: Schema102.Struct({ success: Schema102.Boolean }),
+        response: Schema103.Struct({ success: Schema103.Boolean }),
         summary: "Change password (requires current password)",
         tags: ["users"]
       }),
       getConnectedAccounts: defineEndpoint({
         method: "GET",
         path: "/user/connected-accounts",
-        response: Schema102.Array(ConnectedAccount),
+        response: Schema103.Array(ConnectedAccount),
         summary: "List OAuth providers connected to the current account",
         tags: ["users"]
       }),
       getLoginHistory: defineEndpoint({
         method: "GET",
         path: "/user/login-history",
-        response: Schema102.Array(LoginHistoryEntry),
+        response: Schema103.Array(LoginHistoryEntry),
         summary: "Get recent login attempts (last 20)",
         tags: ["users"]
       }),
       getSessions: defineEndpoint({
         method: "GET",
         path: "/user/sessions",
-        response: Schema102.Array(UserSession),
+        response: Schema103.Array(UserSession),
         summary: "List active sessions",
         tags: ["users"]
       }),
@@ -13140,7 +13296,7 @@ var init_users = __esm({
         method: "DELETE",
         path: "/user/sessions/:sessionId",
         params: SessionIdPath,
-        response: Schema102.Struct({ success: Schema102.Boolean }),
+        response: Schema103.Struct({ success: Schema103.Boolean }),
         summary: "Revoke a specific session",
         tags: ["users"]
       }),
@@ -13170,521 +13326,521 @@ var init_users = __esm({
 });
 
 // ../contract/dist/schemas/webhooks.js
-import { Schema as Schema103 } from "effect";
+import { Schema as Schema104 } from "effect";
 var WebhookStatus, WebhookPeriod, WebhookEnvironment, ProjectRef3, GetWebhookConfigResult, UpdateWebhookConfigInput, UpdateWebhookConfigResult, WebhookDelivery, WebhookDeliveryDetail, ListWebhookDeliveriesQuery, ListWebhookDeliveriesResult, ReplayDeliveryResult, FailedDeliveriesQuery, FailedDelivery, FailedDeliveriesResult, WebhookStatsQuery, WebhookStatsResult, WebhooksAdminOverviewResult, AdminProjectDeliveriesQuery, AdminProjectDeliveryItem, AdminProjectDeliveriesResult, BulkReplayInput, BulkReplayResult;
 var init_webhooks = __esm({
   "../contract/dist/schemas/webhooks.js"() {
     "use strict";
-    WebhookStatus = Schema103.Literal("pending", "queued", "delivered", "failed", "skipped");
-    WebhookPeriod = Schema103.Literal("day", "week", "month");
-    WebhookEnvironment = Schema103.Struct({
-      id: Schema103.String,
-      name: Schema103.String,
-      webhookUrl: Schema103.NullOr(Schema103.String),
-      hasSecret: Schema103.Boolean,
-      updatedAt: Schema103.String
-    });
-    ProjectRef3 = Schema103.Struct({
-      id: Schema103.String,
-      name: Schema103.String,
-      slug: Schema103.String
-    });
-    GetWebhookConfigResult = Schema103.Struct({
+    WebhookStatus = Schema104.Literal("pending", "queued", "delivered", "failed", "skipped");
+    WebhookPeriod = Schema104.Literal("day", "week", "month");
+    WebhookEnvironment = Schema104.Struct({
+      id: Schema104.String,
+      name: Schema104.String,
+      webhookUrl: Schema104.NullOr(Schema104.String),
+      hasSecret: Schema104.Boolean,
+      updatedAt: Schema104.String
+    });
+    ProjectRef3 = Schema104.Struct({
+      id: Schema104.String,
+      name: Schema104.String,
+      slug: Schema104.String
+    });
+    GetWebhookConfigResult = Schema104.Struct({
       app: ProjectRef3,
-      environments: Schema103.Array(WebhookEnvironment),
-      supportedEvents: Schema103.Array(Schema103.String)
-    });
-    UpdateWebhookConfigInput = Schema103.Struct({
-      environmentId: Schema103.String,
-      webhookUrl: Schema103.NullOr(Schema103.String),
-      regenerateSecret: Schema103.optional(Schema103.Boolean)
-    });
-    UpdateWebhookConfigResult = Schema103.Struct({
-      success: Schema103.Boolean,
-      webhookUrl: Schema103.NullOr(Schema103.String),
-      secretGenerated: Schema103.Boolean,
-      webhookSecretPrefix: Schema103.optional(Schema103.String)
-    });
-    WebhookDelivery = Schema103.Struct({
-      id: Schema103.String,
-      event: Schema103.String,
-      url: Schema103.String,
+      environments: Schema104.Array(WebhookEnvironment),
+      supportedEvents: Schema104.Array(Schema104.String)
+    });
+    UpdateWebhookConfigInput = Schema104.Struct({
+      environmentId: Schema104.String,
+      webhookUrl: Schema104.NullOr(Schema104.String),
+      regenerateSecret: Schema104.optional(Schema104.Boolean)
+    });
+    UpdateWebhookConfigResult = Schema104.Struct({
+      success: Schema104.Boolean,
+      webhookUrl: Schema104.NullOr(Schema104.String),
+      secretGenerated: Schema104.Boolean,
+      webhookSecretPrefix: Schema104.optional(Schema104.String)
+    });
+    WebhookDelivery = Schema104.Struct({
+      id: Schema104.String,
+      event: Schema104.String,
+      url: Schema104.String,
       status: WebhookStatus,
-      retryCount: Schema103.Number,
-      responseStatus: Schema103.NullOr(Schema103.Number),
-      error: Schema103.NullOr(Schema103.String),
-      createdAt: Schema103.String,
-      queuedAt: Schema103.NullOr(Schema103.String),
-      deliveredAt: Schema103.NullOr(Schema103.String),
-      failedAt: Schema103.NullOr(Schema103.String)
-    });
-    WebhookDeliveryDetail = Schema103.Struct({
-      id: Schema103.String,
-      event: Schema103.String,
-      url: Schema103.String,
-      payload: Schema103.Record({ key: Schema103.String, value: Schema103.Unknown }),
+      retryCount: Schema104.Number,
+      responseStatus: Schema104.NullOr(Schema104.Number),
+      error: Schema104.NullOr(Schema104.String),
+      createdAt: Schema104.String,
+      queuedAt: Schema104.NullOr(Schema104.String),
+      deliveredAt: Schema104.NullOr(Schema104.String),
+      failedAt: Schema104.NullOr(Schema104.String)
+    });
+    WebhookDeliveryDetail = Schema104.Struct({
+      id: Schema104.String,
+      event: Schema104.String,
+      url: Schema104.String,
+      payload: Schema104.Record({ key: Schema104.String, value: Schema104.Unknown }),
       status: WebhookStatus,
-      messageId: Schema103.NullOr(Schema103.String),
-      responseStatus: Schema103.NullOr(Schema103.Number),
-      error: Schema103.NullOr(Schema103.String),
-      retryCount: Schema103.Number,
-      createdAt: Schema103.String,
-      queuedAt: Schema103.NullOr(Schema103.String),
-      deliveredAt: Schema103.NullOr(Schema103.String),
-      failedAt: Schema103.NullOr(Schema103.String)
-    });
-    ListWebhookDeliveriesQuery = Schema103.Struct({
-      status: Schema103.optional(WebhookStatus),
-      event: Schema103.optional(Schema103.String),
-      limit: Schema103.optional(Schema103.String),
-      offset: Schema103.optional(Schema103.String),
-      environmentId: Schema103.optional(Schema103.String)
-    });
-    ListWebhookDeliveriesResult = Schema103.Struct({
-      deliveries: Schema103.Array(WebhookDelivery),
-      total: Schema103.Number,
-      limit: Schema103.Number,
-      offset: Schema103.Number
-    });
-    ReplayDeliveryResult = Schema103.Struct({
-      success: Schema103.Boolean,
-      newDeliveryId: Schema103.NullOr(Schema103.String),
-      messageId: Schema103.NullOr(Schema103.String)
-    });
-    FailedDeliveriesQuery = Schema103.Struct({
-      limit: Schema103.optional(Schema103.String)
-    });
-    FailedDelivery = Schema103.Struct({
-      id: Schema103.String,
-      event: Schema103.String,
-      url: Schema103.String,
-      error: Schema103.NullOr(Schema103.String),
-      retryCount: Schema103.Number,
-      createdAt: Schema103.String,
-      failedAt: Schema103.NullOr(Schema103.String)
-    });
-    FailedDeliveriesResult = Schema103.Struct({
-      deliveries: Schema103.Array(FailedDelivery),
-      total: Schema103.Number
-    });
-    WebhookStatsQuery = Schema103.Struct({
-      period: Schema103.optional(WebhookPeriod)
-    });
-    WebhookStatsResult = Schema103.Struct({
+      messageId: Schema104.NullOr(Schema104.String),
+      responseStatus: Schema104.NullOr(Schema104.Number),
+      error: Schema104.NullOr(Schema104.String),
+      retryCount: Schema104.Number,
+      createdAt: Schema104.String,
+      queuedAt: Schema104.NullOr(Schema104.String),
+      deliveredAt: Schema104.NullOr(Schema104.String),
+      failedAt: Schema104.NullOr(Schema104.String)
+    });
+    ListWebhookDeliveriesQuery = Schema104.Struct({
+      status: Schema104.optional(WebhookStatus),
+      event: Schema104.optional(Schema104.String),
+      limit: Schema104.optional(Schema104.String),
+      offset: Schema104.optional(Schema104.String),
+      environmentId: Schema104.optional(Schema104.String)
+    });
+    ListWebhookDeliveriesResult = Schema104.Struct({
+      deliveries: Schema104.Array(WebhookDelivery),
+      total: Schema104.Number,
+      limit: Schema104.Number,
+      offset: Schema104.Number
+    });
+    ReplayDeliveryResult = Schema104.Struct({
+      success: Schema104.Boolean,
+      newDeliveryId: Schema104.NullOr(Schema104.String),
+      messageId: Schema104.NullOr(Schema104.String)
+    });
+    FailedDeliveriesQuery = Schema104.Struct({
+      limit: Schema104.optional(Schema104.String)
+    });
+    FailedDelivery = Schema104.Struct({
+      id: Schema104.String,
+      event: Schema104.String,
+      url: Schema104.String,
+      error: Schema104.NullOr(Schema104.String),
+      retryCount: Schema104.Number,
+      createdAt: Schema104.String,
+      failedAt: Schema104.NullOr(Schema104.String)
+    });
+    FailedDeliveriesResult = Schema104.Struct({
+      deliveries: Schema104.Array(FailedDelivery),
+      total: Schema104.Number
+    });
+    WebhookStatsQuery = Schema104.Struct({
+      period: Schema104.optional(WebhookPeriod)
+    });
+    WebhookStatsResult = Schema104.Struct({
       period: WebhookPeriod,
-      totals: Schema103.Struct({
-        total: Schema103.Number,
-        delivered: Schema103.Number,
-        failed: Schema103.Number,
-        pending: Schema103.Number,
-        deliveryRate: Schema103.Number
-      }),
-      byEvent: Schema103.Array(Schema103.Struct({
-        event: Schema103.String,
-        count: Schema103.Number
+      totals: Schema104.Struct({
+        total: Schema104.Number,
+        delivered: Schema104.Number,
+        failed: Schema104.Number,
+        pending: Schema104.Number,
+        deliveryRate: Schema104.Number
+      }),
+      byEvent: Schema104.Array(Schema104.Struct({
+        event: Schema104.String,
+        count: Schema104.Number
       })),
-      byStatus: Schema103.Array(Schema103.Struct({
+      byStatus: Schema104.Array(Schema104.Struct({
         status: WebhookStatus,
-        count: Schema103.Number
+        count: Schema104.Number
       }))
     });
-    WebhooksAdminOverviewResult = Schema103.Struct({
+    WebhooksAdminOverviewResult = Schema104.Struct({
       period: WebhookPeriod,
-      totals: Schema103.Struct({
-        total: Schema103.Number,
-        delivered: Schema103.Number,
-        failed: Schema103.Number,
-        pending: Schema103.Number,
-        deliveryRate: Schema103.Number
-      }),
-      byProject: Schema103.Array(Schema103.Struct({
-        projectId: Schema103.String,
-        projectName: Schema103.String,
-        total: Schema103.Number,
-        delivered: Schema103.Number,
-        failed: Schema103.Number,
-        deliveryRate: Schema103.Number
+      totals: Schema104.Struct({
+        total: Schema104.Number,
+        delivered: Schema104.Number,
+        failed: Schema104.Number,
+        pending: Schema104.Number,
+        deliveryRate: Schema104.Number
+      }),
+      byProject: Schema104.Array(Schema104.Struct({
+        projectId: Schema104.String,
+        projectName: Schema104.String,
+        total: Schema104.Number,
+        delivered: Schema104.Number,
+        failed: Schema104.Number,
+        deliveryRate: Schema104.Number
       })),
-      byEvent: Schema103.Array(Schema103.Struct({
-        event: Schema103.String,
-        count: Schema103.Number
+      byEvent: Schema104.Array(Schema104.Struct({
+        event: Schema104.String,
+        count: Schema104.Number
       })),
-      recentFailures: Schema103.Array(Schema103.Struct({
-        id: Schema103.String,
-        projectId: Schema103.String,
-        projectName: Schema103.String,
-        event: Schema103.String,
-        url: Schema103.String,
-        error: Schema103.NullOr(Schema103.String),
-        retryCount: Schema103.Number,
-        responseStatus: Schema103.NullOr(Schema103.Number),
-        timestamp: Schema103.String,
-        failedAt: Schema103.NullOr(Schema103.String)
+      recentFailures: Schema104.Array(Schema104.Struct({
+        id: Schema104.String,
+        projectId: Schema104.String,
+        projectName: Schema104.String,
+        event: Schema104.String,
+        url: Schema104.String,
+        error: Schema104.NullOr(Schema104.String),
+        retryCount: Schema104.Number,
+        responseStatus: Schema104.NullOr(Schema104.Number),
+        timestamp: Schema104.String,
+        failedAt: Schema104.NullOr(Schema104.String)
       }))
     });
-    AdminProjectDeliveriesQuery = Schema103.Struct({
-      status: Schema103.optional(WebhookStatus),
-      limit: Schema103.optional(Schema103.String)
+    AdminProjectDeliveriesQuery = Schema104.Struct({
+      status: Schema104.optional(WebhookStatus),
+      limit: Schema104.optional(Schema104.String)
     });
-    AdminProjectDeliveryItem = Schema103.Struct({
-      id: Schema103.String,
-      event: Schema103.String,
-      url: Schema103.String,
+    AdminProjectDeliveryItem = Schema104.Struct({
+      id: Schema104.String,
+      event: Schema104.String,
+      url: Schema104.String,
       status: WebhookStatus,
-      retryCount: Schema103.Number,
-      responseStatus: Schema103.NullOr(Schema103.Number),
-      error: Schema103.NullOr(Schema103.String),
-      timestamp: Schema103.String,
-      queuedAt: Schema103.NullOr(Schema103.String),
-      deliveredAt: Schema103.NullOr(Schema103.String),
-      failedAt: Schema103.NullOr(Schema103.String)
-    });
-    AdminProjectDeliveriesResult = Schema103.Array(AdminProjectDeliveryItem);
-    BulkReplayInput = Schema103.Struct({
-      projectId: Schema103.String,
-      deliveryIds: Schema103.optional(Schema103.Array(Schema103.String)),
-      limit: Schema103.optional(Schema103.Number)
-    });
-    BulkReplayResult = Schema103.Struct({
-      total: Schema103.Number,
-      succeeded: Schema103.Number,
-      failed: Schema103.Number,
-      errors: Schema103.optional(Schema103.Array(Schema103.Struct({
-        deliveryId: Schema103.String,
-        error: Schema103.String
+      retryCount: Schema104.Number,
+      responseStatus: Schema104.NullOr(Schema104.Number),
+      error: Schema104.NullOr(Schema104.String),
+      timestamp: Schema104.String,
+      queuedAt: Schema104.NullOr(Schema104.String),
+      deliveredAt: Schema104.NullOr(Schema104.String),
+      failedAt: Schema104.NullOr(Schema104.String)
+    });
+    AdminProjectDeliveriesResult = Schema104.Array(AdminProjectDeliveryItem);
+    BulkReplayInput = Schema104.Struct({
+      projectId: Schema104.String,
+      deliveryIds: Schema104.optional(Schema104.Array(Schema104.String)),
+      limit: Schema104.optional(Schema104.Number)
+    });
+    BulkReplayResult = Schema104.Struct({
+      total: Schema104.Number,
+      succeeded: Schema104.Number,
+      failed: Schema104.Number,
+      errors: Schema104.optional(Schema104.Array(Schema104.Struct({
+        deliveryId: Schema104.String,
+        error: Schema104.String
       })))
     });
   }
 });
 
 // ../contract/dist/errors.js
-import { Schema as Schema104 } from "effect";
+import { Schema as Schema105 } from "effect";
 var BadRequestError, UnauthorizedError, ForbiddenError, NotFoundError, ConflictError, UnprocessableEntityError, RateLimitedError, InternalServerError, ApiError;
 var init_errors = __esm({
   "../contract/dist/errors.js"() {
     "use strict";
-    BadRequestError = Schema104.Struct({
-      _tag: Schema104.Literal("BadRequest"),
-      code: Schema104.String,
-      message: Schema104.String,
-      details: Schema104.optional(Schema104.Unknown)
+    BadRequestError = Schema105.Struct({
+      _tag: Schema105.Literal("BadRequest"),
+      code: Schema105.String,
+      message: Schema105.String,
+      details: Schema105.optional(Schema105.Unknown)
     });
-    UnauthorizedError = Schema104.Struct({
-      _tag: Schema104.Literal("Unauthorized"),
-      code: Schema104.String,
-      message: Schema104.String
+    UnauthorizedError = Schema105.Struct({
+      _tag: Schema105.Literal("Unauthorized"),
+      code: Schema105.String,
+      message: Schema105.String
     });
-    ForbiddenError = Schema104.Struct({
-      _tag: Schema104.Literal("Forbidden"),
-      code: Schema104.String,
-      message: Schema104.String
+    ForbiddenError = Schema105.Struct({
+      _tag: Schema105.Literal("Forbidden"),
+      code: Schema105.String,
+      message: Schema105.String
     });
-    NotFoundError = Schema104.Struct({
-      _tag: Schema104.Literal("NotFound"),
-      code: Schema104.String,
-      message: Schema104.String
+    NotFoundError = Schema105.Struct({
+      _tag: Schema105.Literal("NotFound"),
+      code: Schema105.String,
+      message: Schema105.String
     });
-    ConflictError = Schema104.Struct({
-      _tag: Schema104.Literal("Conflict"),
-      code: Schema104.String,
-      message: Schema104.String
+    ConflictError = Schema105.Struct({
+      _tag: Schema105.Literal("Conflict"),
+      code: Schema105.String,
+      message: Schema105.String
     });
-    UnprocessableEntityError = Schema104.Struct({
-      _tag: Schema104.Literal("UnprocessableEntity"),
-      code: Schema104.String,
-      message: Schema104.String,
-      details: Schema104.optional(Schema104.Unknown)
+    UnprocessableEntityError = Schema105.Struct({
+      _tag: Schema105.Literal("UnprocessableEntity"),
+      code: Schema105.String,
+      message: Schema105.String,
+      details: Schema105.optional(Schema105.Unknown)
     });
-    RateLimitedError = Schema104.Struct({
-      _tag: Schema104.Literal("RateLimited"),
-      code: Schema104.String,
-      message: Schema104.String,
-      retryAfterSeconds: Schema104.optional(Schema104.Number)
+    RateLimitedError = Schema105.Struct({
+      _tag: Schema105.Literal("RateLimited"),
+      code: Schema105.String,
+      message: Schema105.String,
+      retryAfterSeconds: Schema105.optional(Schema105.Number)
     });
-    InternalServerError = Schema104.Struct({
-      _tag: Schema104.Literal("InternalServer"),
-      code: Schema104.String,
-      message: Schema104.String
+    InternalServerError = Schema105.Struct({
+      _tag: Schema105.Literal("InternalServer"),
+      code: Schema105.String,
+      message: Schema105.String
     });
-    ApiError = Schema104.Union(BadRequestError, UnauthorizedError, ForbiddenError, NotFoundError, ConflictError, UnprocessableEntityError, RateLimitedError, InternalServerError);
+    ApiError = Schema105.Union(BadRequestError, UnauthorizedError, ForbiddenError, NotFoundError, ConflictError, UnprocessableEntityError, RateLimitedError, InternalServerError);
   }
 });
 
 // ../contract/dist/schemas/ai.js
-import { Schema as Schema105 } from "effect";
+import { Schema as Schema106 } from "effect";
 var AIUsagePeriod, AIModelCapability, AIModel, GetModelsResponse, TokensBreakdown, CostBreakdown, ModelUsage, TypeUsage, GetUsageResponse, CurrentRateLimitUsage, GetRateLimitResponse;
 var init_ai = __esm({
   "../contract/dist/schemas/ai.js"() {
     "use strict";
-    AIUsagePeriod = Schema105.Literal("day", "week", "month");
-    AIModelCapability = Schema105.Literal("chat", "vision", "tool", "embedding");
-    AIModel = Schema105.Struct({
-      id: Schema105.String,
-      name: Schema105.String,
-      contextWindow: Schema105.Number,
-      capabilities: Schema105.Array(AIModelCapability),
-      inputCostPer1M: Schema105.Number,
-      outputCostPer1M: Schema105.Number,
-      description: Schema105.optional(Schema105.String)
-    });
-    GetModelsResponse = Schema105.Struct({
-      models: Schema105.Array(AIModel),
-      nextCursor: Schema105.NullOr(Schema105.String),
-      hasMore: Schema105.Boolean
-    });
-    TokensBreakdown = Schema105.Struct({
-      input: Schema105.Number,
-      output: Schema105.Number,
-      total: Schema105.Number
-    });
-    CostBreakdown = Schema105.Struct({
-      microdollars: Schema105.Number,
-      formatted: Schema105.String
-    });
-    ModelUsage = Schema105.Struct({
-      requests: Schema105.Number,
-      tokens: Schema105.Number,
-      cost: Schema105.Number
-    });
-    TypeUsage = Schema105.Struct({
-      requests: Schema105.Number,
-      tokens: Schema105.Number
-    });
-    GetUsageResponse = Schema105.Struct({
+    AIUsagePeriod = Schema106.Literal("day", "week", "month");
+    AIModelCapability = Schema106.Literal("chat", "vision", "tool", "embedding");
+    AIModel = Schema106.Struct({
+      id: Schema106.String,
+      name: Schema106.String,
+      contextWindow: Schema106.Number,
+      capabilities: Schema106.Array(AIModelCapability),
+      inputCostPer1M: Schema106.Number,
+      outputCostPer1M: Schema106.Number,
+      description: Schema106.optional(Schema106.String)
+    });
+    GetModelsResponse = Schema106.Struct({
+      models: Schema106.Array(AIModel),
+      nextCursor: Schema106.NullOr(Schema106.String),
+      hasMore: Schema106.Boolean
+    });
+    TokensBreakdown = Schema106.Struct({
+      input: Schema106.Number,
+      output: Schema106.Number,
+      total: Schema106.Number
+    });
+    CostBreakdown = Schema106.Struct({
+      microdollars: Schema106.Number,
+      formatted: Schema106.String
+    });
+    ModelUsage = Schema106.Struct({
+      requests: Schema106.Number,
+      tokens: Schema106.Number,
+      cost: Schema106.Number
+    });
+    TypeUsage = Schema106.Struct({
+      requests: Schema106.Number,
+      tokens: Schema106.Number
+    });
+    GetUsageResponse = Schema106.Struct({
       period: AIUsagePeriod,
-      requests: Schema105.Number,
+      requests: Schema106.Number,
       tokens: TokensBreakdown,
       cost: CostBreakdown,
-      byModel: Schema105.Record({ key: Schema105.String, value: ModelUsage }),
-      byType: Schema105.Record({ key: Schema105.String, value: TypeUsage })
-    });
-    CurrentRateLimitUsage = Schema105.Struct({
-      requestsThisMinute: Schema105.Number,
-      requestsToday: Schema105.Number,
-      tokensThisMinute: Schema105.Number,
-      tokensToday: Schema105.Number,
-      costToday: Schema105.Number
-    });
-    GetRateLimitResponse = Schema105.Struct({
-      requestsPerMinute: Schema105.NullOr(Schema105.Number),
-      requestsPerDay: Schema105.NullOr(Schema105.Number),
-      tokensPerMinute: Schema105.NullOr(Schema105.Number),
-      tokensPerDay: Schema105.NullOr(Schema105.Number),
-      costPerDayMicrodollars: Schema105.NullOr(Schema105.Number),
+      byModel: Schema106.Record({ key: Schema106.String, value: ModelUsage }),
+      byType: Schema106.Record({ key: Schema106.String, value: TypeUsage })
+    });
+    CurrentRateLimitUsage = Schema106.Struct({
+      requestsThisMinute: Schema106.Number,
+      requestsToday: Schema106.Number,
+      tokensThisMinute: Schema106.Number,
+      tokensToday: Schema106.Number,
+      costToday: Schema106.Number
+    });
+    GetRateLimitResponse = Schema106.Struct({
+      requestsPerMinute: Schema106.NullOr(Schema106.Number),
+      requestsPerDay: Schema106.NullOr(Schema106.Number),
+      tokensPerMinute: Schema106.NullOr(Schema106.Number),
+      tokensPerDay: Schema106.NullOr(Schema106.Number),
+      costPerDayMicrodollars: Schema106.NullOr(Schema106.Number),
       current: CurrentRateLimitUsage
     });
   }
 });
 
 // ../contract/dist/schemas/billing.js
-import { Schema as Schema106 } from "effect";
+import { Schema as Schema107 } from "effect";
 var SdkBillingInterval, SdkBillingSubscriptionStatus, SdkBillingStatusLevel, SdkBillingType, SdkBillingTrustLevel, SdkBillingPlan, BillingPlansListResponse, SdkBillingSubscription, BillingSubscriptionResponse, BillingCheckoutRequest, BillingCheckoutResponse, BillingPortalRequest, BillingPortalResponse, SdkBillingBalanceInfo, SdkBillingStatusInfo, BillingBalanceResponse, SdkBillingUsagePeriod, SdkBillingUsageMetrics, BillingUsageResponse;
 var init_billing = __esm({
   "../contract/dist/schemas/billing.js"() {
     "use strict";
-    SdkBillingInterval = Schema106.Literal("monthly", "annual", "lifetime");
-    SdkBillingSubscriptionStatus = Schema106.Literal("active", "canceled", "past_due", "incomplete", "trialing", "paused");
-    SdkBillingStatusLevel = Schema106.Literal("healthy", "low", "critical", "exhausted");
-    SdkBillingType = Schema106.Literal("prepaid", "postpaid", "enterprise");
-    SdkBillingTrustLevel = Schema106.Literal("new", "standard", "trusted", "enterprise");
-    SdkBillingPlan = Schema106.Struct({
-      id: Schema106.String,
-      slug: Schema106.String,
-      name: Schema106.String,
-      description: Schema106.NullOr(Schema106.String),
-      features: Schema106.Array(Schema106.String),
-      monthlyPrice: Schema106.Number,
-      annualPrice: Schema106.Number,
-      lifetimePrice: Schema106.NullOr(Schema106.Number),
-      isPopular: Schema106.Boolean,
-      isActive: Schema106.Boolean,
-      sortOrder: Schema106.Number
-    });
-    BillingPlansListResponse = Schema106.Array(SdkBillingPlan);
-    SdkBillingSubscription = Schema106.Struct({
-      id: Schema106.String,
-      userId: Schema106.String,
-      planId: Schema106.String,
-      planSlug: Schema106.String,
-      planName: Schema106.String,
+    SdkBillingInterval = Schema107.Literal("monthly", "annual", "lifetime");
+    SdkBillingSubscriptionStatus = Schema107.Literal("active", "canceled", "past_due", "incomplete", "trialing", "paused");
+    SdkBillingStatusLevel = Schema107.Literal("healthy", "low", "critical", "exhausted");
+    SdkBillingType = Schema107.Literal("prepaid", "postpaid", "enterprise");
+    SdkBillingTrustLevel = Schema107.Literal("new", "standard", "trusted", "enterprise");
+    SdkBillingPlan = Schema107.Struct({
+      id: Schema107.String,
+      slug: Schema107.String,
+      name: Schema107.String,
+      description: Schema107.NullOr(Schema107.String),
+      features: Schema107.Array(Schema107.String),
+      monthlyPrice: Schema107.Number,
+      annualPrice: Schema107.Number,
+      lifetimePrice: Schema107.NullOr(Schema107.Number),
+      isPopular: Schema107.Boolean,
+      isActive: Schema107.Boolean,
+      sortOrder: Schema107.Number
+    });
+    BillingPlansListResponse = Schema107.Array(SdkBillingPlan);
+    SdkBillingSubscription = Schema107.Struct({
+      id: Schema107.String,
+      userId: Schema107.String,
+      planId: Schema107.String,
+      planSlug: Schema107.String,
+      planName: Schema107.String,
       status: SdkBillingSubscriptionStatus,
       interval: SdkBillingInterval,
-      currentPeriodStart: Schema106.NullOr(Schema106.String),
-      currentPeriodEnd: Schema106.NullOr(Schema106.String),
-      cancelAtPeriodEnd: Schema106.Boolean,
-      trialEnd: Schema106.NullOr(Schema106.String)
-    });
-    BillingSubscriptionResponse = Schema106.NullOr(SdkBillingSubscription);
-    BillingCheckoutRequest = Schema106.Struct({
-      userId: Schema106.String,
-      planSlug: Schema106.String,
+      currentPeriodStart: Schema107.NullOr(Schema107.String),
+      currentPeriodEnd: Schema107.NullOr(Schema107.String),
+      cancelAtPeriodEnd: Schema107.Boolean,
+      trialEnd: Schema107.NullOr(Schema107.String)
+    });
+    BillingSubscriptionResponse = Schema107.NullOr(SdkBillingSubscription);
+    BillingCheckoutRequest = Schema107.Struct({
+      userId: Schema107.String,
+      planSlug: Schema107.String,
       interval: SdkBillingInterval,
-      successUrl: Schema106.String,
-      cancelUrl: Schema106.String
+      successUrl: Schema107.String,
+      cancelUrl: Schema107.String
     });
-    BillingCheckoutResponse = Schema106.Struct({
-      checkoutUrl: Schema106.NullOr(Schema106.String),
-      sessionId: Schema106.String
+    BillingCheckoutResponse = Schema107.Struct({
+      checkoutUrl: Schema107.NullOr(Schema107.String),
+      sessionId: Schema107.String
     });
-    BillingPortalRequest = Schema106.Struct({
-      userId: Schema106.String,
-      returnUrl: Schema106.String
+    BillingPortalRequest = Schema107.Struct({
+      userId: Schema107.String,
+      returnUrl: Schema107.String
     });
-    BillingPortalResponse = Schema106.Struct({
-      portalUrl: Schema106.String
+    BillingPortalResponse = Schema107.Struct({
+      portalUrl: Schema107.String
     });
-    SdkBillingBalanceInfo = Schema106.Struct({
-      current: Schema106.Number,
-      currentFormatted: Schema106.String
+    SdkBillingBalanceInfo = Schema107.Struct({
+      current: Schema107.Number,
+      currentFormatted: Schema107.String
     });
-    SdkBillingStatusInfo = Schema106.Struct({
+    SdkBillingStatusInfo = Schema107.Struct({
       level: SdkBillingStatusLevel,
-      isHealthy: Schema106.Boolean,
-      isLow: Schema106.Boolean,
-      alertThreshold: Schema106.Number
+      isHealthy: Schema107.Boolean,
+      isLow: Schema107.Boolean,
+      alertThreshold: Schema107.Number
     });
-    BillingBalanceResponse = Schema106.Struct({
+    BillingBalanceResponse = Schema107.Struct({
       balance: SdkBillingBalanceInfo,
       status: SdkBillingStatusInfo,
       billingType: SdkBillingType,
       trustLevel: SdkBillingTrustLevel,
-      spendingCap: Schema106.NullOr(Schema106.Number),
-      currentMonthSpend: Schema106.Number,
-      spendingCapPercent: Schema106.NullOr(Schema106.Number),
-      gracePeriodEndsAt: Schema106.NullOr(Schema106.String),
-      isAdminOrg: Schema106.Boolean
-    });
-    SdkBillingUsagePeriod = Schema106.Struct({
-      type: Schema106.Literal("month"),
-      start: Schema106.String,
-      end: Schema106.String
-    });
-    SdkBillingUsageMetrics = Schema106.Struct({
-      aiCostMicrodollars: Schema106.Number,
-      storageBytesUsed: Schema106.Number,
-      storageEgressBytes: Schema106.Number,
-      storageUploads: Schema106.Number,
-      dbStorageBytes: Schema106.Number,
-      dbComputeSeconds: Schema106.Number,
-      emailSentCount: Schema106.Number,
-      jobInvocationCount: Schema106.Number,
-      cronActiveCount: Schema106.Number,
-      notificationsSentCount: Schema106.Number,
-      analyticsEventCount: Schema106.Number,
-      webhookDeliveryCount: Schema106.Number,
-      errorEventCount: Schema106.Number,
-      authMau: Schema106.Number
-    });
-    BillingUsageResponse = Schema106.Struct({
+      spendingCap: Schema107.NullOr(Schema107.Number),
+      currentMonthSpend: Schema107.Number,
+      spendingCapPercent: Schema107.NullOr(Schema107.Number),
+      gracePeriodEndsAt: Schema107.NullOr(Schema107.String),
+      isAdminOrg: Schema107.Boolean
+    });
+    SdkBillingUsagePeriod = Schema107.Struct({
+      type: Schema107.Literal("month"),
+      start: Schema107.String,
+      end: Schema107.String
+    });
+    SdkBillingUsageMetrics = Schema107.Struct({
+      aiCostMicrodollars: Schema107.Number,
+      storageBytesUsed: Schema107.Number,
+      storageEgressBytes: Schema107.Number,
+      storageUploads: Schema107.Number,
+      dbStorageBytes: Schema107.Number,
+      dbComputeSeconds: Schema107.Number,
+      emailSentCount: Schema107.Number,
+      jobInvocationCount: Schema107.Number,
+      cronActiveCount: Schema107.Number,
+      notificationsSentCount: Schema107.Number,
+      analyticsEventCount: Schema107.Number,
+      webhookDeliveryCount: Schema107.Number,
+      errorEventCount: Schema107.Number,
+      authMau: Schema107.Number
+    });
+    BillingUsageResponse = Schema107.Struct({
       period: SdkBillingUsagePeriod,
-      metrics: Schema106.NullOr(SdkBillingUsageMetrics)
+      metrics: Schema107.NullOr(SdkBillingUsageMetrics)
     });
   }
 });
 
 // ../contract/dist/schemas/consent.js
-import { Schema as Schema107 } from "effect";
+import { Schema as Schema108 } from "effect";
 var SdkConsentCategory, SdkConsentType, UserConsent, ConsentItem, SetConsentsRequest, SetConsentsResponse;
 var init_consent = __esm({
   "../contract/dist/schemas/consent.js"() {
     "use strict";
-    SdkConsentCategory = Schema107.Literal("necessary", "analytics", "marketing", "preferences", "functional");
-    SdkConsentType = Schema107.Struct({
-      id: Schema107.String,
-      slug: Schema107.String,
+    SdkConsentCategory = Schema108.Literal("necessary", "analytics", "marketing", "preferences", "functional");
+    SdkConsentType = Schema108.Struct({
+      id: Schema108.String,
+      slug: Schema108.String,
       category: SdkConsentCategory,
-      name: Schema107.String,
-      description: Schema107.String,
-      required: Schema107.Boolean,
-      defaultEnabled: Schema107.Boolean
+      name: Schema108.String,
+      description: Schema108.String,
+      required: Schema108.Boolean,
+      defaultEnabled: Schema108.Boolean
     });
-    UserConsent = Schema107.Struct({
-      slug: Schema107.String,
+    UserConsent = Schema108.Struct({
+      slug: Schema108.String,
       category: SdkConsentCategory,
-      name: Schema107.String,
-      required: Schema107.Boolean,
-      granted: Schema107.Boolean,
-      grantedAt: Schema107.NullOr(Schema107.String),
-      version: Schema107.NullOr(Schema107.Number)
+      name: Schema108.String,
+      required: Schema108.Boolean,
+      granted: Schema108.Boolean,
+      grantedAt: Schema108.NullOr(Schema108.String),
+      version: Schema108.NullOr(Schema108.Number)
     });
-    ConsentItem = Schema107.Struct({
-      slug: Schema107.String,
-      granted: Schema107.Boolean
+    ConsentItem = Schema108.Struct({
+      slug: Schema108.String,
+      granted: Schema108.Boolean
     });
-    SetConsentsRequest = Schema107.Struct({
-      userId: Schema107.optional(Schema107.String),
-      anonymousId: Schema107.optional(Schema107.String),
-      consents: Schema107.Array(ConsentItem),
-      source: Schema107.optional(Schema107.Literal("banner", "settings", "api")),
-      userAgent: Schema107.optional(Schema107.String)
+    SetConsentsRequest = Schema108.Struct({
+      userId: Schema108.optional(Schema108.String),
+      anonymousId: Schema108.optional(Schema108.String),
+      consents: Schema108.Array(ConsentItem),
+      source: Schema108.optional(Schema108.Literal("banner", "settings", "api")),
+      userAgent: Schema108.optional(Schema108.String)
     });
-    SetConsentsResponse = Schema107.Struct({
-      consents: Schema107.Array(ConsentItem)
+    SetConsentsResponse = Schema108.Struct({
+      consents: Schema108.Array(ConsentItem)
     });
   }
 });
 
 // ../contract/dist/schemas/referrals.js
-import { Schema as Schema108 } from "effect";
+import { Schema as Schema109 } from "effect";
 var ReferralCodeStatus, ReferralLeaderboardPeriod, ReferralRewardKind, ReferralRewardConfig, ReferralRewardDefaults, GetCodeResponse, RegenerateCodeResponse, GetStatsResponse, RedeemRequest, RedeemResponse, ReferralLeaderboardEntry, ReferralLeaderboardResponse;
 var init_referrals = __esm({
   "../contract/dist/schemas/referrals.js"() {
     "use strict";
-    ReferralCodeStatus = Schema108.Literal("pending", "completed", "expired");
-    ReferralLeaderboardPeriod = Schema108.Literal("all", "month", "week");
-    ReferralRewardKind = Schema108.Literal("points", "premium_trial", "discount", "credit");
-    ReferralRewardConfig = Schema108.Struct({
+    ReferralCodeStatus = Schema109.Literal("pending", "completed", "expired");
+    ReferralLeaderboardPeriod = Schema109.Literal("all", "month", "week");
+    ReferralRewardKind = Schema109.Literal("points", "premium_trial", "discount", "credit");
+    ReferralRewardConfig = Schema109.Struct({
       type: ReferralRewardKind,
-      points: Schema108.optional(Schema108.Number),
-      days: Schema108.optional(Schema108.Number),
-      discountPercent: Schema108.optional(Schema108.Number),
-      creditCents: Schema108.optional(Schema108.Number)
-    });
-    ReferralRewardDefaults = Schema108.Struct({
-      referrerReward: Schema108.optional(ReferralRewardConfig),
-      refereeReward: Schema108.optional(ReferralRewardConfig),
-      doubleReward: Schema108.optional(Schema108.Boolean),
-      minimumDaysBeforeReward: Schema108.optional(Schema108.Number)
-    });
-    GetCodeResponse = Schema108.Struct({
-      code: Schema108.String,
+      points: Schema109.optional(Schema109.Number),
+      days: Schema109.optional(Schema109.Number),
+      discountPercent: Schema109.optional(Schema109.Number),
+      creditCents: Schema109.optional(Schema109.Number)
+    });
+    ReferralRewardDefaults = Schema109.Struct({
+      referrerReward: Schema109.optional(ReferralRewardConfig),
+      refereeReward: Schema109.optional(ReferralRewardConfig),
+      doubleReward: Schema109.optional(Schema109.Boolean),
+      minimumDaysBeforeReward: Schema109.optional(Schema109.Number)
+    });
+    GetCodeResponse = Schema109.Struct({
+      code: Schema109.String,
       status: ReferralCodeStatus
     });
-    RegenerateCodeResponse = Schema108.Struct({
-      code: Schema108.String,
-      totalReferrals: Schema108.Number,
-      completedReferrals: Schema108.Number,
-      pendingReferrals: Schema108.Number
-    });
-    GetStatsResponse = Schema108.Struct({
-      totalReferrals: Schema108.Number,
-      completedReferrals: Schema108.Number,
-      pendingReferrals: Schema108.Number
-    });
-    RedeemRequest = Schema108.Struct({
-      code: Schema108.String,
-      defaults: Schema108.optional(ReferralRewardDefaults)
-    });
-    RedeemResponse = Schema108.Struct({
-      success: Schema108.Boolean,
-      rewardType: Schema108.String,
-      referredReward: Schema108.optional(Schema108.Record({ key: Schema108.String, value: Schema108.Unknown })),
-      referrerReward: Schema108.optional(Schema108.Record({ key: Schema108.String, value: Schema108.Unknown }))
-    });
-    ReferralLeaderboardEntry = Schema108.Struct({
-      rank: Schema108.Number,
-      userId: Schema108.NullOr(Schema108.String),
-      displayName: Schema108.String,
-      avatarUrl: Schema108.NullOr(Schema108.String),
-      value: Schema108.Number,
-      isCurrentUser: Schema108.Boolean,
-      metadata: Schema108.optional(Schema108.Record({ key: Schema108.String, value: Schema108.Unknown })),
-      submittedAt: Schema108.String
-    });
-    ReferralLeaderboardResponse = Schema108.Struct({
+    RegenerateCodeResponse = Schema109.Struct({
+      code: Schema109.String,
+      totalReferrals: Schema109.Number,
+      completedReferrals: Schema109.Number,
+      pendingReferrals: Schema109.Number
+    });
+    GetStatsResponse = Schema109.Struct({
+      totalReferrals: Schema109.Number,
+      completedReferrals: Schema109.Number,
+      pendingReferrals: Schema109.Number
+    });
+    RedeemRequest = Schema109.Struct({
+      code: Schema109.String,
+      defaults: Schema109.optional(ReferralRewardDefaults)
+    });
+    RedeemResponse = Schema109.Struct({
+      success: Schema109.Boolean,
+      rewardType: Schema109.String,
+      referredReward: Schema109.optional(Schema109.Record({ key: Schema109.String, value: Schema109.Unknown })),
+      referrerReward: Schema109.optional(Schema109.Record({ key: Schema109.String, value: Schema109.Unknown }))
+    });
+    ReferralLeaderboardEntry = Schema109.Struct({
+      rank: Schema109.Number,
+      userId: Schema109.NullOr(Schema109.String),
+      displayName: Schema109.String,
+      avatarUrl: Schema109.NullOr(Schema109.String),
+      value: Schema109.Number,
+      isCurrentUser: Schema109.Boolean,
+      metadata: Schema109.optional(Schema109.Record({ key: Schema109.String, value: Schema109.Unknown })),
+      submittedAt: Schema109.String
+    });
+    ReferralLeaderboardResponse = Schema109.Struct({
       period: ReferralLeaderboardPeriod,
-      entries: Schema108.Array(ReferralLeaderboardEntry),
-      currentUserRank: Schema108.NullOr(Schema108.Number)
+      entries: Schema109.Array(ReferralLeaderboardEntry),
+      currentUserRank: Schema109.NullOr(Schema109.Number)
     });
   }
 });
@@ -13716,6 +13872,7 @@ var init_dist = __esm({
     init_env_vars();
     init_environments();
     init_organizations();
+    init_project_manifest2();
     init_projects();
     init_saml2();
     init_secrets();
@@ -15251,9 +15408,11 @@ var projects_exports = {};
 __export(projects_exports, {
   create: () => create9,
   delete: () => _delete8,
-  list: () => list14
+  getManifest: () => getManifest,
+  list: () => list14,
+  putManifest: () => putManifest
 });
-var orgHeaders6, list14, create9, _delete8;
+var orgHeaders6, list14, create9, _delete8, getManifest, putManifest;
 var init_projects2 = __esm({
   "../management/dist/projects.js"() {
     "use strict";
@@ -15277,6 +15436,14 @@ var init_projects2 = __esm({
       const { method, path: path6 } = projectsEndpoints2.delete;
       return request(client, method, interpolatePath(path6, { id }));
     };
+    getManifest = (client, id) => {
+      const { method, path: path6 } = projectManifestEndpoints.get;
+      return request(client, method, interpolatePath(path6, { id }));
+    };
+    putManifest = (client, id, manifest) => {
+      const { method, path: path6 } = projectManifestEndpoints.put;
+      return request(client, method, interpolatePath(path6, { id }), { body: manifest });
+    };
   }
 });
 
@@ -21296,7 +21463,7 @@ import { Console as Console12, Effect as Effect21 } from "effect";
 
 // src/lib/manifest.ts
 init_dist();
-import { Data as Data3, Effect as Effect20, Either, ParseResult, Schema as Schema109 } from "effect";
+import { Data as Data3, Effect as Effect20, Either, ParseResult, Schema as Schema110 } from "effect";
 var MANIFEST_FILENAME = "sylphx.toml";
 var ManifestFileNotFoundError = class extends Data3.TaggedError("ManifestFileNotFoundError") {
   get message() {
@@ -21360,7 +21527,7 @@ function parseTomlEffect(source, path6) {
   });
 }
 function validateManifestEffect(parsed, path6) {
-  const either = Schema109.decodeUnknownEither(SylphxManifest, {
+  const either = Schema110.decodeUnknownEither(SylphxManifest, {
     errors: "all",
     // Reject typos + unknown keys so users catch mistakes locally rather
     // than having the server silently drop fields on apply.
@@ -21409,6 +21576,11 @@ function renderManifestToml(manifest) {
     parts.push(...kv(manifest.deploy));
     parts.push("");
   }
+  if (manifest.database?.migrations) {
+    parts.push("[database.migrations]");
+    parts.push(...kv(manifest.database.migrations));
+    parts.push("");
+  }
   if (manifest.services) {
     for (const svc of manifest.services) {
       parts.push("[[services]]");
@@ -21437,11 +21609,21 @@ function renderManifestToml(manifest) {
       parts.push(...kv(r.database));
       parts.push("");
     }
+    if (r.kv) {
+      parts.push("[resources.kv]");
+      parts.push(...kv(r.kv));
+      parts.push("");
+    }
     if (r.search) {
       parts.push("[resources.search]");
       parts.push(...kv(r.search));
       parts.push("");
     }
+    if (r.volume) {
+      parts.push("[resources.volume]");
+      parts.push(...kv(r.volume));
+      parts.push("");
+    }
   }
   if (manifest.environments) {
     for (const [envName, override] of Object.entries(manifest.environments)) {