@eide/foir-cli 0.2.0 → 0.3.1

package/dist/cli.js

@@ -448,26 +448,2240 @@ function registerLogoutCommand(program2, globalOpts) {
 import inquirer from "inquirer";
 
 // src/lib/client.ts
-import { createClient } from "@connectrpc/connect";
+import { createClient as createRpcClient } from "@connectrpc/connect";
 import { createConnectTransport } from "@connectrpc/connect-node";
+import { IdentityService as IdentityService2 } from "@eide/foir-proto-ts/identity/v1/identity_pb";
+import { ModelsService as ModelsService2 } from "@eide/foir-proto-ts/models/v1/models_pb";
+import { RecordsService as RecordsService2 } from "@eide/foir-proto-ts/records/v1/records_pb";
+import { ConfigsService as ConfigsService2 } from "@eide/foir-proto-ts/configs/v1/configs_pb";
+import { SegmentsService as SegmentsService2 } from "@eide/foir-proto-ts/segments/v1/segments_pb";
+import { ExperimentsService as ExperimentsService2 } from "@eide/foir-proto-ts/experiments/v1/experiments_pb";
+import { SettingsService as SettingsService2 } from "@eide/foir-proto-ts/settings/v1/settings_pb";
+import { StorageService as StorageService2 } from "@eide/foir-proto-ts/storage/v1/storage_pb";
+
+// src/lib/rpc/identity.ts
+import { create } from "@bufbuild/protobuf";
+import {
+  LoginRequestSchema,
+  LoginWithOTPRequestSchema,
+  RequestOTPRequestSchema,
+  LogoutRequestSchema,
+  GetMeRequestSchema,
+  GetSessionContextRequestSchema,
+  SwitchTenantRequestSchema,
+  SwitchProjectRequestSchema,
+  ClearSessionContextRequestSchema,
+  RefreshTokenRequestSchema,
+  RegisterRequestSchema,
+  VerifyEmailRequestSchema,
+  ResendVerificationEmailRequestSchema,
+  UpdatePasswordRequestSchema,
+  RequestPasswordResetRequestSchema,
+  ResetPasswordRequestSchema,
+  SendEmailVerificationCodeRequestSchema,
+  VerifyEmailCodeRequestSchema,
+  CreateAdminUserRequestSchema,
+  GetAdminUserRequestSchema,
+  UpdateAdminUserRequestSchema,
+  ListAdminUsersRequestSchema,
+  GrantAccessRequestSchema,
+  RevokeAccessRequestSchema,
+  CreateCustomerRequestSchema,
+  GetCustomerRequestSchema,
+  UpdateCustomerRequestSchema,
+  DeleteCustomerRequestSchema,
+  ListCustomersRequestSchema,
+  SuspendCustomerRequestSchema,
+  CreateTenantRequestSchema,
+  GetTenantRequestSchema,
+  UpdateTenantRequestSchema,
+  ListTenantsRequestSchema,
+  DeleteTenantRequestSchema,
+  CreateProjectRequestSchema,
+  GetProjectRequestSchema,
+  UpdateProjectRequestSchema,
+  ListProjectsRequestSchema,
+  DeleteProjectRequestSchema,
+  GetDefaultProjectRequestSchema,
+  SetDefaultProjectRequestSchema,
+  CreateInvitationRequestSchema,
+  ListInvitationsRequestSchema,
+  RevokeInvitationRequestSchema,
+  AcceptInvitationRequestSchema,
+  ValidateInvitationRequestSchema,
+  CreateApiKeyRequestSchema,
+  GetApiKeyRequestSchema,
+  ListApiKeysRequestSchema,
+  UpdateApiKeyRequestSchema,
+  RotateApiKeyRequestSchema,
+  RevokeApiKeyRequestSchema,
+  MintServiceTokenRequestSchema,
+  ListAuthProvidersRequestSchema,
+  GetAuthProviderRequestSchema,
+  CreateAuthProviderRequestSchema,
+  UpdateAuthProviderRequestSchema,
+  DeleteAuthProviderRequestSchema,
+  EnabledOAuthProvidersRequestSchema,
+  CheckEmailAvailabilityRequestSchema,
+  CompleteAccountSetupRequestSchema,
+  CreateSignupSessionRequestSchema,
+  UpdateMyProfileRequestSchema,
+  ListMyOAuthConnectionsRequestSchema,
+  UnlinkOAuthProviderRequestSchema,
+  ResendInvitationRequestSchema,
+  GetCustomerAuthConfigRequestSchema,
+  VerifyCustomerTokenRequestSchema,
+  GetCustomerManagementStatusRequestSchema
+} from "@eide/foir-proto-ts/identity/v1/identity_pb";
+import {
+  InviteType,
+  AccessRole,
+  CustomerStatus,
+  AdminUserStatus,
+  TenantStatus,
+  ProjectStatus,
+  InvitationStatus
+} from "@eide/foir-proto-ts/identity/v1/identity_pb";
+function createIdentityMethods(client) {
+  return {
+    // ── Auth ──────────────────────────────────────────────
+    async login(email, password, tenantId, projectId) {
+      const resp = await client.login(
+        create(LoginRequestSchema, { email, password, tenantId, projectId })
+      );
+      return {
+        sessionId: resp.sessionId,
+        user: resp.user ?? null
+      };
+    },
+    async loginWithOTP(email, otp, tenantId, projectId) {
+      const resp = await client.loginWithOTP(
+        create(LoginWithOTPRequestSchema, { email, otp, tenantId, projectId })
+      );
+      return {
+        sessionId: resp.sessionId,
+        user: resp.user ?? null
+      };
+    },
+    async requestOTP(email, tenantId, projectId) {
+      const resp = await client.requestOTP(
+        create(RequestOTPRequestSchema, { email, tenantId, projectId })
+      );
+      return { success: resp.success };
+    },
+    async logout() {
+      const resp = await client.logout(create(LogoutRequestSchema, {}));
+      return { success: resp.success };
+    },
+    async register(params) {
+      const resp = await client.register(
+        create(RegisterRequestSchema, {
+          email: params.email,
+          password: params.password,
+          tenantId: params.tenantId,
+          projectId: params.projectId,
+          role: params.role
+        })
+      );
+      return { user: resp.user ?? null };
+    },
+    // ── Email Verification ────────────────────────────────
+    async verifyEmail(token) {
+      const resp = await client.verifyEmail(
+        create(VerifyEmailRequestSchema, { token })
+      );
+      return { success: resp.success };
+    },
+    async resendVerificationEmail() {
+      const resp = await client.resendVerificationEmail(
+        create(ResendVerificationEmailRequestSchema, {})
+      );
+      return { success: resp.success };
+    },
+    async sendEmailVerificationCode(email) {
+      const resp = await client.sendEmailVerificationCode(
+        create(SendEmailVerificationCodeRequestSchema, { email })
+      );
+      return { success: resp.success };
+    },
+    async verifyEmailCode(email, code) {
+      const resp = await client.verifyEmailCode(
+        create(VerifyEmailCodeRequestSchema, { email, code })
+      );
+      return { success: resp.success, verified: resp.verified };
+    },
+    // ── Password ──────────────────────────────────────────
+    async updatePassword(currentPassword, newPassword) {
+      const resp = await client.updatePassword(
+        create(UpdatePasswordRequestSchema, { currentPassword, newPassword })
+      );
+      return { success: resp.success };
+    },
+    async requestPasswordReset(email) {
+      const resp = await client.requestPasswordReset(
+        create(RequestPasswordResetRequestSchema, { email })
+      );
+      return { success: resp.success };
+    },
+    async resetPassword(token, newPassword) {
+      const resp = await client.resetPassword(
+        create(ResetPasswordRequestSchema, { token, newPassword })
+      );
+      return { success: resp.success };
+    },
+    // ── Session Context ───────────────────────────────────
+    async getMe() {
+      const resp = await client.getMe(create(GetMeRequestSchema, {}));
+      return { user: resp.user ?? null };
+    },
+    async getSessionContext() {
+      const resp = await client.getSessionContext(
+        create(GetSessionContextRequestSchema, {})
+      );
+      return resp.context ?? null;
+    },
+    async switchTenant(tenantId) {
+      const resp = await client.switchTenant(
+        create(SwitchTenantRequestSchema, { tenantId })
+      );
+      return resp.context ?? null;
+    },
+    async switchProject(projectId) {
+      const resp = await client.switchProject(
+        create(SwitchProjectRequestSchema, { projectId })
+      );
+      return resp.context ?? null;
+    },
+    async clearSessionContext() {
+      await client.clearSessionContext(
+        create(ClearSessionContextRequestSchema, {})
+      );
+      return { success: true };
+    },
+    async refreshToken(refreshToken) {
+      const resp = await client.refreshToken(
+        create(RefreshTokenRequestSchema, { refreshToken })
+      );
+      return { accessToken: resp.accessToken, refreshToken: resp.refreshToken };
+    },
+    // ── Admin Users ───────────────────────────────────────
+    async createAdminUser(params) {
+      const resp = await client.createAdminUser(
+        create(CreateAdminUserRequestSchema, params)
+      );
+      return { user: resp.user ?? null };
+    },
+    async getAdminUser(id) {
+      const resp = await client.getAdminUser(
+        create(GetAdminUserRequestSchema, { id })
+      );
+      return { user: resp.user ?? null };
+    },
+    async updateAdminUser(params) {
+      const resp = await client.updateAdminUser(
+        create(UpdateAdminUserRequestSchema, params)
+      );
+      return { user: resp.user ?? null };
+    },
+    async listAdminUsers(params = {}) {
+      const resp = await client.listAdminUsers(
+        create(ListAdminUsersRequestSchema, {
+          search: params.search,
+          status: params.status,
+          role: params.role,
+          limit: params.limit ?? 50,
+          offset: params.offset ?? 0
+        })
+      );
+      return {
+        items: resp.items ?? [],
+        total: Number(resp.total)
+      };
+    },
+    async grantAccess(params) {
+      const resp = await client.grantAccess(
+        create(GrantAccessRequestSchema, params)
+      );
+      return { access: resp.access ?? null };
+    },
+    async revokeAccess(accessId) {
+      const resp = await client.revokeAccess(
+        create(RevokeAccessRequestSchema, { accessId })
+      );
+      return { success: resp.success };
+    },
+    // ── Customers ─────────────────────────────────────────
+    async createCustomer(params) {
+      const resp = await client.createCustomer(
+        create(CreateCustomerRequestSchema, {
+          email: params.email,
+          password: params.password
+        })
+      );
+      return {
+        customer: resp.customer ?? null
+      };
+    },
+    async getCustomer(id) {
+      const resp = await client.getCustomer(
+        create(GetCustomerRequestSchema, { id })
+      );
+      return {
+        customer: resp.customer ?? null
+      };
+    },
+    async updateCustomer(params) {
+      const resp = await client.updateCustomer(
+        create(UpdateCustomerRequestSchema, {
+          id: params.id,
+          email: params.email,
+          status: params.status
+        })
+      );
+      return {
+        customer: resp.customer ?? null
+      };
+    },
+    async deleteCustomer(id) {
+      const resp = await client.deleteCustomer(
+        create(DeleteCustomerRequestSchema, { id })
+      );
+      return { success: resp.success };
+    },
+    async listCustomers(params = {}) {
+      const resp = await client.listCustomers(
+        create(ListCustomersRequestSchema, {
+          search: params.search,
+          status: params.status,
+          limit: params.limit ?? 50,
+          offset: params.offset ?? 0
+        })
+      );
+      return {
+        items: resp.items ?? [],
+        total: Number(resp.total)
+      };
+    },
+    async suspendCustomer(id) {
+      const resp = await client.suspendCustomer(
+        create(SuspendCustomerRequestSchema, { id })
+      );
+      return {
+        customer: resp.customer ?? null
+      };
+    },
+    // ── Tenants ───────────────────────────────────────────
+    async createTenant(params) {
+      const resp = await client.createTenant(
+        create(CreateTenantRequestSchema, { name: params.name })
+      );
+      return { tenant: resp.tenant ?? null };
+    },
+    async getTenant(id) {
+      const resp = await client.getTenant(
+        create(GetTenantRequestSchema, { id })
+      );
+      return { tenant: resp.tenant ?? null };
+    },
+    async updateTenant(params) {
+      const resp = await client.updateTenant(
+        create(UpdateTenantRequestSchema, {
+          id: params.id,
+          name: params.name,
+          status: params.status
+        })
+      );
+      return { tenant: resp.tenant ?? null };
+    },
+    async listTenants(params = {}) {
+      const resp = await client.listTenants(
+        create(ListTenantsRequestSchema, {
+          status: params.status,
+          limit: params.limit ?? 50,
+          offset: params.offset ?? 0
+        })
+      );
+      return {
+        items: resp.items ?? [],
+        total: Number(resp.total)
+      };
+    },
+    async deleteTenant(id) {
+      const resp = await client.deleteTenant(
+        create(DeleteTenantRequestSchema, { id })
+      );
+      return { success: resp.success };
+    },
+    // ── Projects ──────────────────────────────────────────
+    async createProject(params) {
+      const resp = await client.createProject(
+        create(CreateProjectRequestSchema, {
+          tenantId: params.tenantId,
+          name: params.name,
+          description: params.description
+        })
+      );
+      return { project: resp.project ?? null };
+    },
+    async getProject(id) {
+      const resp = await client.getProject(
+        create(GetProjectRequestSchema, { id })
+      );
+      return { project: resp.project ?? null };
+    },
+    async updateProject(params) {
+      const resp = await client.updateProject(
+        create(UpdateProjectRequestSchema, {
+          id: params.id,
+          name: params.name,
+          description: params.description
+        })
+      );
+      return { project: resp.project ?? null };
+    },
+    async listProjects(params) {
+      const resp = await client.listProjects(
+        create(ListProjectsRequestSchema, {
+          tenantId: params.tenantId,
+          status: params.status,
+          limit: params.limit ?? 50,
+          offset: params.offset ?? 0
+        })
+      );
+      return {
+        items: resp.items ?? [],
+        total: Number(resp.total)
+      };
+    },
+    async deleteProject(id) {
+      const resp = await client.deleteProject(
+        create(DeleteProjectRequestSchema, { id })
+      );
+      return { success: resp.success };
+    },
+    async getDefaultProject(tenantId) {
+      const resp = await client.getDefaultProject(
+        create(GetDefaultProjectRequestSchema, { tenantId })
+      );
+      return { project: resp.project ?? null };
+    },
+    async setDefaultProject(params) {
+      const resp = await client.setDefaultProject(
+        create(SetDefaultProjectRequestSchema, {
+          projectId: params.projectId
+        })
+      );
+      return { project: resp.project ?? null };
+    },
+    // ── Invitations ───────────────────────────────────────
+    async createInvitation(params) {
+      const resp = await client.createInvitation(
+        create(CreateInvitationRequestSchema, {
+          email: params.email,
+          tenantId: params.tenantId,
+          projectIds: params.projectIds ?? [],
+          role: params.role,
+          inviteType: params.inviteType,
+          message: params.message
+        })
+      );
+      return {
+        invitation: resp.invitation ?? null
+      };
+    },
+    async listInvitations(params) {
+      const resp = await client.listInvitations(
+        create(ListInvitationsRequestSchema, {
+          tenantId: params.tenantId,
+          status: params.status,
+          limit: params.limit ?? 50,
+          offset: params.offset ?? 0
+        })
+      );
+      return {
+        items: resp.items ?? [],
+        total: Number(resp.total)
+      };
+    },
+    async revokeInvitation(invitationId) {
+      const resp = await client.revokeInvitation(
+        create(RevokeInvitationRequestSchema, { invitationId })
+      );
+      return { success: resp.success };
+    },
+    async acceptInvitation(params) {
+      const resp = await client.acceptInvitation(
+        create(AcceptInvitationRequestSchema, {
+          token: params.token,
+          password: params.password
+        })
+      );
+      return {
+        user: resp.user ?? null,
+        sessionId: resp.sessionId
+      };
+    },
+    async validateInvitation(params) {
+      const resp = await client.validateInvitation(
+        create(ValidateInvitationRequestSchema, { token: params.token })
+      );
+      return {
+        invitation: resp.invitation ?? null
+      };
+    },
+    // ── API Keys ──────────────────────────────────────────
+    async createApiKey(params) {
+      const resp = await client.createApiKey(
+        create(CreateApiKeyRequestSchema, {
+          name: params.name,
+          keyType: params.keyType,
+          rateLimitPerHour: params.rateLimitPerHour
+        })
+      );
+      return { apiKey: resp.apiKey ?? null };
+    },
+    async getApiKey(id) {
+      const resp = await client.getApiKey(
+        create(GetApiKeyRequestSchema, { id })
+      );
+      return { apiKey: resp.apiKey ?? null };
+    },
+    async listApiKeys(params = {}) {
+      const resp = await client.listApiKeys(
+        create(ListApiKeysRequestSchema, {
+          limit: params.limit ?? 50,
+          offset: params.offset ?? 0
+        })
+      );
+      return {
+        items: resp.items ?? [],
+        total: Number(resp.total)
+      };
+    },
+    async updateApiKey(params) {
+      const resp = await client.updateApiKey(
+        create(UpdateApiKeyRequestSchema, {
+          id: params.id,
+          name: params.name,
+          isActive: params.isActive,
+          rateLimitPerHour: params.rateLimitPerHour
+        })
+      );
+      return { apiKey: resp.apiKey ?? null };
+    },
+    async rotateApiKey(id) {
+      const resp = await client.rotateApiKey(
+        create(RotateApiKeyRequestSchema, { id })
+      );
+      return { apiKey: resp.apiKey ?? null };
+    },
+    async revokeApiKey(id) {
+      const resp = await client.revokeApiKey(
+        create(RevokeApiKeyRequestSchema, { id })
+      );
+      return { success: resp.success };
+    },
+    // ── Service Tokens ──────────────────────────────────────────
+    async mintServiceToken(purpose) {
+      const resp = await client.mintServiceToken(
+        create(MintServiceTokenRequestSchema, { purpose })
+      );
+      return {
+        token: resp.token,
+        purpose: resp.purpose,
+        expiresAt: resp.expiresAt
+      };
+    },
+    // ── Auth Providers ───────────────────────────────────────
+    async listAuthProviders(params = {}) {
+      const resp = await client.listAuthProviders(
+        create(ListAuthProvidersRequestSchema, {
+          enabled: params.enabled,
+          limit: params.limit ?? 50,
+          offset: params.offset ?? 0
+        })
+      );
+      return {
+        items: resp.providers ?? [],
+        total: resp.total
+      };
+    },
+    async getAuthProvider(id) {
+      const resp = await client.getAuthProvider(
+        create(GetAuthProviderRequestSchema, { id })
+      );
+      return resp.provider ?? null;
+    },
+    async createAuthProvider(params) {
+      const resp = await client.createAuthProvider(
+        create(CreateAuthProviderRequestSchema, {
+          key: params.key,
+          name: params.name,
+          type: params.type,
+          config: params.config,
+          enabled: params.enabled,
+          isDefault: params.isDefault,
+          priority: params.priority
+        })
+      );
+      return resp.provider ?? null;
+    },
+    async updateAuthProvider(params) {
+      const resp = await client.updateAuthProvider(
+        create(UpdateAuthProviderRequestSchema, {
+          id: params.id,
+          name: params.name,
+          config: params.config,
+          enabled: params.enabled,
+          isDefault: params.isDefault,
+          priority: params.priority
+        })
+      );
+      return resp.provider ?? null;
+    },
+    async deleteAuthProvider(id) {
+      const resp = await client.deleteAuthProvider(
+        create(DeleteAuthProviderRequestSchema, { id })
+      );
+      return resp.success;
+    },
+    async enabledOAuthProviders() {
+      const resp = await client.enabledOAuthProviders(
+        create(EnabledOAuthProvidersRequestSchema, {})
+      );
+      return resp.providers ?? [];
+    },
+    // ── Signup / Account Setup ───────────────────────────────
+    async checkEmailAvailability(email) {
+      const resp = await client.checkEmailAvailability(
+        create(CheckEmailAvailabilityRequestSchema, { email })
+      );
+      return { available: resp.available };
+    },
+    async completeAccountSetup(params) {
+      const resp = await client.completeAccountSetup(
+        create(CompleteAccountSetupRequestSchema, {
+          firstName: params.firstName,
+          lastName: params.lastName,
+          password: params.password
+        })
+      );
+      return {
+        success: resp.success,
+        redirectUrl: resp.redirectUrl ?? void 0
+      };
+    },
+    async createSignupSession(userId) {
+      const resp = await client.createSignupSession(
+        create(CreateSignupSessionRequestSchema, { userId })
+      );
+      return { success: resp.success };
+    },
+    // ── Profile / OAuth ───────────────────────────────────────
+    async updateMyProfile(params) {
+      const resp = await client.updateMyProfile(
+        create(UpdateMyProfileRequestSchema, {
+          firstName: params.firstName,
+          lastName: params.lastName,
+          avatarUrl: params.avatarUrl
+        })
+      );
+      return resp.user ?? null;
+    },
+    async listMyOAuthConnections() {
+      const resp = await client.listMyOAuthConnections(
+        create(ListMyOAuthConnectionsRequestSchema, {})
+      );
+      return resp.connections ?? [];
+    },
+    async unlinkOAuthProvider(provider) {
+      const resp = await client.unlinkOAuthProvider(
+        create(UnlinkOAuthProviderRequestSchema, { provider })
+      );
+      return resp.success;
+    },
+    // ── Invitations (additional) ─────────────────────────────
+    async resendInvitation(invitationId) {
+      const resp = await client.resendInvitation(
+        create(ResendInvitationRequestSchema, { invitationId })
+      );
+      return resp.success;
+    },
+    // ── Customer Auth ────────────────────────────────────────
+    async getCustomerAuthConfig() {
+      const resp = await client.getCustomerAuthConfig(
+        create(GetCustomerAuthConfigRequestSchema, {})
+      );
+      return resp.config ?? null;
+    },
+    async verifyCustomerToken(token) {
+      const resp = await client.verifyCustomerToken(
+        create(VerifyCustomerTokenRequestSchema, { token })
+      );
+      return resp;
+    },
+    async getCustomerManagementStatus() {
+      const resp = await client.getCustomerManagementStatus(
+        create(GetCustomerManagementStatusRequestSchema, {})
+      );
+      return resp.status ?? null;
+    }
+  };
+}
+
+// src/lib/rpc/models.ts
+import { create as create2 } from "@bufbuild/protobuf";
+import {
+  FieldSchema as ProtoFieldSchema,
+  SharingConfigSchema as ProtoSharingConfigSchema,
+  ModelConfigSchema as ProtoModelConfigSchema,
+  CreateModelRequestSchema,
+  GetModelRequestSchema,
+  GetModelByKeyRequestSchema,
+  ListModelsRequestSchema,
+  UpdateModelRequestSchema,
+  DeleteModelRequestSchema,
+  DuplicateModelRequestSchema,
+  ListModelVersionsRequestSchema,
+  RestoreModelVersionRequestSchema
+} from "@eide/foir-proto-ts/models/v1/models_pb";
+function jsFieldToProto(f) {
+  return create2(ProtoFieldSchema, {
+    id: f.id,
+    key: f.key,
+    label: f.label,
+    type: f.type,
+    required: f.required,
+    helpText: f.helpText,
+    placeholder: f.placeholder,
+    config: f.config && Object.keys(f.config).length > 0 ? f.config : void 0,
+    itemType: f.itemType,
+    storage: f.storage,
+    templateZone: f.templateZone,
+    zoneOrder: f.zoneOrder
+  });
+}
+function jsConfigToProto(c) {
+  return create2(ProtoModelConfigSchema, {
+    versioning: c.versioning ?? false,
+    publishing: c.publishing ?? false,
+    variants: c.variants ?? false,
+    inline: c.inline ?? false,
+    customerScoped: c.customerScoped ?? false,
+    sharing: c.sharing ? create2(ProtoSharingConfigSchema, {
+      enabled: c.sharing.enabled,
+      requireAcceptance: c.sharing.requireAcceptance
+    }) : void 0,
+    pluralName: c.pluralName,
+    description: c.description,
+    category: c.category,
+    icon: c.icon,
+    displayField: c.displayField,
+    naturalKeyField: c.naturalKeyField,
+    systemEntity: c.systemEntity ?? false,
+    deletable: c.deletable,
+    editable: c.editable
+  });
+}
+function createModelsMethods(client) {
+  return {
+    // ── Queries ──────────────────────────────────────────────
+    async getModel(id) {
+      const resp = await client.getModel(create2(GetModelRequestSchema, { id }));
+      return resp.model ?? null;
+    },
+    async getModelByKey(key) {
+      const resp = await client.getModelByKey(
+        create2(GetModelByKeyRequestSchema, { key })
+      );
+      return resp.model ?? null;
+    },
+    async listModels(params = {}) {
+      const resp = await client.listModels(
+        create2(ListModelsRequestSchema, {
+          search: params.search,
+          category: params.category,
+          configId: params.configId,
+          limit: params.limit ?? 50,
+          offset: params.offset ?? 0
+        })
+      );
+      return {
+        items: resp.models ?? [],
+        total: resp.total
+      };
+    },
+    // ── Mutations ────────────────────────────────────────────
+    async createModel(params) {
+      const resp = await client.createModel(
+        create2(CreateModelRequestSchema, {
+          key: params.key,
+          name: params.name,
+          fields: params.fields.map(jsFieldToProto),
+          config: params.config ? jsConfigToProto(params.config) : void 0,
+          configId: params.configId
+        })
+      );
+      return resp.model ?? null;
+    },
+    async updateModel(params) {
+      const resp = await client.updateModel(
+        create2(UpdateModelRequestSchema, {
+          id: params.id,
+          name: params.name,
+          updateFields: params.fields != null,
+          fields: params.fields?.map(jsFieldToProto) ?? [],
+          config: params.config ? jsConfigToProto(params.config) : void 0,
+          changeDescription: params.changeDescription
+        })
+      );
+      return resp.model ?? null;
+    },
+    async deleteModel(id) {
+      const resp = await client.deleteModel(
+        create2(DeleteModelRequestSchema, { id })
+      );
+      return resp.success;
+    },
+    async duplicateModel(params) {
+      const resp = await client.duplicateModel(
+        create2(DuplicateModelRequestSchema, params)
+      );
+      return resp.model ?? null;
+    },
+    // ── Versioning ───────────────────────────────────────────
+    async listModelVersions(modelId, params = {}) {
+      const resp = await client.listModelVersions(
+        create2(ListModelVersionsRequestSchema, {
+          modelId,
+          limit: params.limit ?? 50,
+          offset: params.offset ?? 0
+        })
+      );
+      return {
+        items: resp.versions ?? [],
+        total: resp.total
+      };
+    },
+    async restoreModelVersion(modelId, versionId) {
+      const resp = await client.restoreModelVersion(
+        create2(RestoreModelVersionRequestSchema, { modelId, versionId })
+      );
+      return resp.model ?? null;
+    }
+  };
+}
+
+// src/lib/rpc/records.ts
+import { create as create3 } from "@bufbuild/protobuf";
+import {
+  CreateRecordRequestSchema,
+  GetRecordRequestSchema,
+  GetRecordByKeyRequestSchema,
+  GetRecordByKeyOrIdRequestSchema,
+  ListRecordsRequestSchema,
+  UpdateRecordRequestSchema,
+  DeleteRecordRequestSchema,
+  DuplicateRecordRequestSchema,
+  DuplicateRecordsBulkRequestSchema,
+  BatchRecordOperationsRequestSchema,
+  BatchOperationSchema,
+  RecordFilterSchema,
+  BulkUpdateRecordsRequestSchema,
+  CreateVersionRequestSchema,
+  PublishVersionRequestSchema,
+  UnpublishRecordRequestSchema,
+  RevertToVersionRequestSchema,
+  ListRecordVersionsRequestSchema,
+  SaveContentRequestSchema,
+  CreateVariantRequestSchema,
+  UpdateVariantRequestSchema,
+  DeleteVariantRequestSchema,
+  SetDefaultVariantRequestSchema,
+  ListRecordVariantsRequestSchema,
+  ScheduleRecordPublishRequestSchema,
+  CancelScheduledRecordPublishRequestSchema,
+  ListScheduledPublishesRequestSchema,
+  ListDraftVersionsRequestSchema,
+  BatchPublishVersionsRequestSchema,
+  CreatePublishBatchRequestSchema,
+  UpdatePublishBatchRequestSchema,
+  CancelPublishBatchRequestSchema,
+  RollbackPublishBatchRequestSchema,
+  RetryFailedBatchItemsRequestSchema,
+  AddItemsToPublishBatchRequestSchema,
+  RemoveItemsFromPublishBatchRequestSchema,
+  ListPublishBatchesRequestSchema,
+  GetPublishBatchRequestSchema,
+  GlobalSearchRequestSchema,
+  GetEmbeddingStatsRequestSchema,
+  GetRecordEmbeddingsRequestSchema,
+  FindSimilarRecordsRequestSchema
+} from "@eide/foir-proto-ts/records/v1/records_pb";
+import { RecordType, BatchStatus } from "@eide/foir-proto-ts/records/v1/records_pb";
+function sanitizeData(obj) {
+  const result = {};
+  for (const [key, value] of Object.entries(obj)) {
+    if (value === void 0) continue;
+    if (value !== null && typeof value === "object" && !Array.isArray(value)) {
+      result[key] = sanitizeData(value);
+    } else if (Array.isArray(value)) {
+      result[key] = value.map((item) => {
+        if (item === void 0) return null;
+        if (item !== null && typeof item === "object" && !Array.isArray(item)) {
+          return sanitizeData(item);
+        }
+        return item;
+      });
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function createRecordsMethods(client) {
+  return {
+    // ── CRUD ──────────────────────────────────────────────────
+    async createRecord(params) {
+      const resp = await client.createRecord(
+        create3(CreateRecordRequestSchema, {
+          modelKey: params.modelKey,
+          naturalKey: params.naturalKey,
+          data: params.data ? sanitizeData(params.data) : void 0,
+          customerId: params.customerId,
+          metadata: params.metadata ? sanitizeData(params.metadata) : void 0,
+          changeDescription: params.changeDescription
+        })
+      );
+      return {
+        record: resp.record ?? null,
+        variant: resp.variant ?? null,
+        version: resp.version ?? null
+      };
+    },
+    async getRecord(id) {
+      const resp = await client.getRecord(
+        create3(GetRecordRequestSchema, { id })
+      );
+      return resp.record ?? null;
+    },
+    async getRecordByKey(modelKey, naturalKey) {
+      const resp = await client.getRecordByKey(
+        create3(GetRecordByKeyRequestSchema, { modelKey, naturalKey })
+      );
+      return resp.record ?? null;
+    },
+    async getRecordByKeyOrId(modelKey, identifier) {
+      const resp = await client.getRecordByKeyOrId(
+        create3(GetRecordByKeyOrIdRequestSchema, { modelKey, identifier })
+      );
+      return resp.record ?? null;
+    },
+    async listRecords(params) {
+      const resp = await client.listRecords(
+        create3(ListRecordsRequestSchema, {
+          modelKey: params.modelKey,
+          limit: params.limit ?? 50,
+          offset: params.offset ?? 0,
+          customerId: params.customerId,
+          search: params.search,
+          filters: params.filters?.map(
+            (f) => create3(RecordFilterSchema, {
+              field: f.field,
+              operator: f.operator
+            })
+          )
+        })
+      );
+      return {
+        items: resp.records ?? [],
+        total: resp.total
+      };
+    },
+    async updateRecord(params) {
+      const resp = await client.updateRecord(
+        create3(UpdateRecordRequestSchema, {
+          id: params.id,
+          data: sanitizeData(params.data),
+          naturalKey: params.naturalKey
+        })
+      );
+      return resp.record ?? null;
+    },
+    async deleteRecord(id) {
+      const resp = await client.deleteRecord(
+        create3(DeleteRecordRequestSchema, { id })
+      );
+      return resp.success;
+    },
+    async duplicateRecord(id, newNaturalKey) {
+      const resp = await client.duplicateRecord(
+        create3(DuplicateRecordRequestSchema, { id, newNaturalKey })
+      );
+      return resp.record ?? null;
+    },
+    async duplicateRecordsBulk(ids, modelKey) {
+      const resp = await client.duplicateRecordsBulk(
+        create3(DuplicateRecordsBulkRequestSchema, { ids, modelKey })
+      );
+      return resp.records ?? [];
+    },
+    async batchRecordOperations(operations) {
+      const typeMap = { create: 1, update: 2, delete: 3 };
+      const resp = await client.batchRecordOperations(
+        create3(BatchRecordOperationsRequestSchema, {
+          operations: operations.map(
+            (op) => create3(BatchOperationSchema, {
+              type: typeMap[op.type],
+              id: op.id,
+              modelKey: op.modelKey,
+              naturalKey: op.naturalKey,
+              data: op.data ? sanitizeData(
+                op.data
+              ) : void 0,
+              customerId: op.customerId
+            })
+          )
+        })
+      );
+      return resp.results ?? [];
+    },
+    async bulkUpdateRecords(params) {
+      const resp = await client.bulkUpdateRecords(
+        create3(BulkUpdateRecordsRequestSchema, {
+          modelKey: params.modelKey,
+          data: sanitizeData(params.data)
+        })
+      );
+      return { count: resp.count };
+    },
+    // ── Versioning ────────────────────────────────────────────
+    async createVersion(parentId, data, changeDescription) {
+      const resp = await client.createVersion(
+        create3(CreateVersionRequestSchema, {
+          parentId,
+          data: data ? sanitizeData(data) : void 0,
+          changeDescription
+        })
+      );
+      return resp.version ?? null;
+    },
+    async publishVersion(versionId) {
+      const resp = await client.publishVersion(
+        create3(PublishVersionRequestSchema, { versionId })
+      );
+      return resp.record ?? null;
+    },
+    async unpublishRecord(recordId) {
+      const resp = await client.unpublishRecord(
+        create3(UnpublishRecordRequestSchema, { recordId })
+      );
+      return resp.success;
+    },
+    async revertToVersion(versionId) {
+      const resp = await client.revertToVersion(
+        create3(RevertToVersionRequestSchema, { versionId })
+      );
+      return resp.record ?? null;
+    },
+    async listRecordVersions(parentId, params) {
+      const resp = await client.listRecordVersions(
+        create3(ListRecordVersionsRequestSchema, {
+          parentId,
+          limit: params?.limit ?? 50,
+          offset: params?.offset ?? 0
+        })
+      );
+      return {
+        items: resp.versions ?? [],
+        total: resp.total
+      };
+    },
+    async saveContent(params) {
+      const resp = await client.saveContent(
+        create3(SaveContentRequestSchema, {
+          recordId: params.recordId,
+          data: sanitizeData(params.data),
+          variantKey: params.variantKey,
+          changeDescription: params.changeDescription
+        })
+      );
+      return {
+        record: resp.record ?? null,
+        version: resp.version ?? null
+      };
+    },
+    // ── Variants ──────────────────────────────────────────────
+    async createVariant(recordId, variantKey, data) {
+      const resp = await client.createVariant(
+        create3(CreateVariantRequestSchema, {
+          recordId,
+          variantKey,
+          data: data ? sanitizeData(data) : void 0
+        })
+      );
+      return resp.variant ?? null;
+    },
+    async updateVariant(variantId, data) {
+      const resp = await client.updateVariant(
+        create3(UpdateVariantRequestSchema, {
+          variantId,
+          data: sanitizeData(data)
+        })
+      );
+      return resp.variant ?? null;
+    },
+    async deleteVariant(variantId) {
+      const resp = await client.deleteVariant(
+        create3(DeleteVariantRequestSchema, { variantId })
+      );
+      return resp.success;
+    },
+    async setDefaultVariant(recordId, variantId) {
+      const resp = await client.setDefaultVariant(
+        create3(SetDefaultVariantRequestSchema, { recordId, variantId })
+      );
+      return resp.record ?? null;
+    },
+    async listRecordVariants(recordId, params) {
+      const resp = await client.listRecordVariants(
+        create3(ListRecordVariantsRequestSchema, {
+          recordId,
+          limit: params?.limit ?? 50,
+          offset: params?.offset ?? 0
+        })
+      );
+      return {
+        items: resp.variants ?? [],
+        total: resp.total
+      };
+    },
+    // ── Scheduling ────────────────────────────────────────────
+    async scheduleRecordPublish(versionId, publishAt, unpublishAt) {
+      const resp = await client.scheduleRecordPublish(
+        create3(ScheduleRecordPublishRequestSchema, {
+          versionId,
+          publishAt: {
+            seconds: BigInt(Math.floor(publishAt.getTime() / 1e3)),
+            nanos: 0
+          },
+          unpublishAt: unpublishAt ? {
+            seconds: BigInt(Math.floor(unpublishAt.getTime() / 1e3)),
+            nanos: 0
+          } : void 0
+        })
+      );
+      return resp.version ?? null;
+    },
+    async cancelScheduledRecordPublish(versionId) {
+      const resp = await client.cancelScheduledRecordPublish(
+        create3(CancelScheduledRecordPublishRequestSchema, { versionId })
+      );
+      return resp.version ?? null;
+    },
+    async listScheduledPublishes(params) {
+      const resp = await client.listScheduledPublishes(
+        create3(ListScheduledPublishesRequestSchema, {
+          from: params?.from ? {
+            seconds: BigInt(Math.floor(params.from.getTime() / 1e3)),
+            nanos: 0
+          } : void 0,
+          to: params?.to ? {
+            seconds: BigInt(Math.floor(params.to.getTime() / 1e3)),
+            nanos: 0
+          } : void 0,
+          modelKey: params?.modelKey,
+          limit: params?.limit ?? 50,
+          offset: params?.offset ?? 0
+        })
+      );
+      return {
+        items: resp.versions ?? [],
+        total: resp.total
+      };
+    },
+    async listDraftVersions(params) {
+      const resp = await client.listDraftVersions(
+        create3(ListDraftVersionsRequestSchema, {
+          modelKey: params?.modelKey,
+          search: params?.search,
+          limit: params?.limit ?? 50,
+          offset: params?.offset ?? 0
+        })
+      );
+      return {
+        items: resp.versions ?? [],
+        total: resp.total
+      };
+    },
+    // ── Batch Publishing ──────────────────────────────────────
+    async batchPublishVersions(versionIds) {
+      const resp = await client.batchPublishVersions(
+        create3(BatchPublishVersionsRequestSchema, { versionIds })
+      );
+      return {
+        records: resp.records ?? [],
+        publishedCount: resp.publishedCount
+      };
+    },
+    // ── Publish Batches ───────────────────────────────────────
+    async createPublishBatch(params) {
+      const resp = await client.createPublishBatch(
+        create3(CreatePublishBatchRequestSchema, {
+          name: params.name,
+          versionIds: params.versionIds,
+          scheduledAt: params.scheduledAt ? {
+            seconds: BigInt(
+              Math.floor(params.scheduledAt.getTime() / 1e3)
+            ),
+            nanos: 0
+          } : void 0
+        })
+      );
+      return resp.batch ?? null;
+    },
+    async updatePublishBatch(params) {
+      const resp = await client.updatePublishBatch(
+        create3(UpdatePublishBatchRequestSchema, {
+          batchId: params.batchId,
+          name: params.name,
+          scheduledAt: params.scheduledAt ? {
+            seconds: BigInt(
+              Math.floor(params.scheduledAt.getTime() / 1e3)
+            ),
+            nanos: 0
+          } : void 0
+        })
+      );
+      return resp.batch ?? null;
+    },
+    async cancelPublishBatch(batchId) {
+      const resp = await client.cancelPublishBatch(
+        create3(CancelPublishBatchRequestSchema, { batchId })
+      );
+      return resp.batch ?? null;
+    },
+    async rollbackPublishBatch(batchId) {
+      const resp = await client.rollbackPublishBatch(
+        create3(RollbackPublishBatchRequestSchema, { batchId })
+      );
+      return resp.batch ?? null;
+    },
+    async retryFailedBatchItems(batchId) {
+      const resp = await client.retryFailedBatchItems(
+        create3(RetryFailedBatchItemsRequestSchema, { batchId })
+      );
+      return {
+        batch: resp.batch ?? null,
+        retriedCount: resp.retriedCount
+      };
+    },
+    async addItemsToPublishBatch(batchId, versionIds) {
+      const resp = await client.addItemsToPublishBatch(
+        create3(AddItemsToPublishBatchRequestSchema, { batchId, versionIds })
+      );
+      return resp.batch ?? null;
+    },
+    async removeItemsFromPublishBatch(batchId, versionIds) {
+      const resp = await client.removeItemsFromPublishBatch(
+        create3(RemoveItemsFromPublishBatchRequestSchema, {
+          batchId,
+          versionIds
+        })
+      );
+      return resp.batch ?? null;
+    },
+    async listPublishBatches(params) {
+      const resp = await client.listPublishBatches(
+        create3(ListPublishBatchesRequestSchema, {
+          status: params?.status,
+          from: params?.from ? {
+            seconds: BigInt(Math.floor(params.from.getTime() / 1e3)),
+            nanos: 0
+          } : void 0,
+          to: params?.to ? {
+            seconds: BigInt(Math.floor(params.to.getTime() / 1e3)),
+            nanos: 0
+          } : void 0,
+          limit: params?.limit ?? 50,
+          offset: params?.offset ?? 0
+        })
+      );
+      return {
+        items: resp.batches ?? [],
+        total: resp.total
+      };
+    },
+    async getPublishBatch(batchId) {
+      const resp = await client.getPublishBatch(
+        create3(GetPublishBatchRequestSchema, { batchId })
+      );
+      return {
+        batch: resp.batch ?? null,
+        versions: resp.versions ?? []
+      };
+    },
+    // ── Search & Embeddings ──────────────────────────────────
+    async globalSearch(params) {
+      const resp = await client.globalSearch(
+        create3(GlobalSearchRequestSchema, {
+          query: params.query,
+          modelKeys: params.modelKeys ?? [],
+          limit: params.limit ?? 20
+        })
+      );
+      return {
+        items: resp.records ?? [],
+        total: resp.total
+      };
+    },
+    async getEmbeddingStats(modelKey) {
+      const resp = await client.getEmbeddingStats(
+        create3(GetEmbeddingStatsRequestSchema, {
+          modelKey
+        })
+      );
+      return resp.stats ?? [];
+    },
+    async getRecordEmbeddings(recordId) {
+      const resp = await client.getRecordEmbeddings(
+        create3(GetRecordEmbeddingsRequestSchema, { recordId })
+      );
+      return resp.embeddings ?? [];
+    },
+    async findSimilarRecords(params) {
+      const resp = await client.findSimilarRecords(
+        create3(FindSimilarRecordsRequestSchema, {
+          recordId: params.recordId,
+          modelKey: params.modelKey,
+          limit: params.limit ?? 10
+        })
+      );
+      return resp.records ?? [];
+    }
+  };
+}
+
+// src/lib/rpc/configs.ts
+import { create as create4 } from "@bufbuild/protobuf";
+import {
+  CreateConfigRequestSchema,
+  GetConfigRequestSchema,
+  GetConfigByKeyRequestSchema,
+  ListConfigsRequestSchema,
+  UpdateConfigRequestSchema,
+  DeleteConfigRequestSchema,
+  ConfigDirection,
+  ListOperationsRequestSchema,
+  ApplyConfigRequestSchema
+} from "@eide/foir-proto-ts/configs/v1/configs_pb";
+import { ConfigDirection as ConfigDirection2 } from "@eide/foir-proto-ts/configs/v1/configs_pb";
+var DIRECTION_TO_PROTO = {
+  read: ConfigDirection.READ,
+  write: ConfigDirection.WRITE,
+  bidirectional: ConfigDirection.BIDIRECTIONAL
+};
+function createConfigsMethods(client) {
+  return {
+    // ── Operations ────────────────────────────────────────────
+    async listOperations(params = {}) {
+      return client.listOperations(
+        create4(ListOperationsRequestSchema, {
+          category: params.category,
+          isActive: params.isActive,
+          search: params.search,
+          limit: params.limit ?? 50,
+          offset: params.offset ?? 0
+        })
+      );
+    },
+    // ── Queries ──────────────────────────────────────────────
+    async getConfig(id) {
+      const resp = await client.getConfig(
+        create4(GetConfigRequestSchema, { id })
+      );
+      return resp.config ?? null;
+    },
+    async getConfigByKey(key) {
+      const resp = await client.getConfigByKey(
+        create4(GetConfigByKeyRequestSchema, { key })
+      );
+      return resp.config ?? null;
+    },
+    async listConfigs(params = {}) {
+      return client.listConfigs(
+        create4(ListConfigsRequestSchema, {
+          configType: params.configType,
+          enabled: params.enabled,
+          limit: params.limit ?? 50,
+          offset: params.offset ?? 0
+        })
+      );
+    },
+    // ── Mutations ────────────────────────────────────────────
+    async createConfig(params) {
+      const resp = await client.createConfig(
+        create4(CreateConfigRequestSchema, {
+          key: params.key,
+          configType: params.configType,
+          direction: DIRECTION_TO_PROTO[params.direction ?? "read"] ?? ConfigDirection.READ,
+          name: params.name,
+          description: params.description,
+          config: params.config,
+          enabled: params.enabled
+        })
+      );
+      return resp.config ?? null;
+    },
+    async updateConfig(params) {
+      const resp = await client.updateConfig(
+        create4(UpdateConfigRequestSchema, {
+          id: params.id,
+          name: params.name,
+          description: params.description,
+          config: params.config,
+          enabled: params.enabled,
+          webhooks: params.webhooks,
+          hooks: params.hooks
+        })
+      );
+      return resp.config ?? null;
+    },
+    async applyConfig(configKey, configData) {
+      const resp = await client.applyConfig(
+        create4(ApplyConfigRequestSchema, {
+          configKey,
+          configData
+        })
+      );
+      return resp.config ?? null;
+    },
+    async deleteConfig(id) {
+      const resp = await client.deleteConfig(
+        create4(DeleteConfigRequestSchema, { id })
+      );
+      return resp.success;
+    }
+  };
+}
+
+// src/lib/rpc/segments.ts
+import { create as create5 } from "@bufbuild/protobuf";
+import {
+  CreateSegmentRequestSchema,
+  GetSegmentRequestSchema,
+  GetSegmentByKeyRequestSchema,
+  ListSegmentsRequestSchema,
+  UpdateSegmentRequestSchema,
+  DeleteSegmentRequestSchema,
+  GetCustomerMembershipsRequestSchema,
+  PreviewSegmentRulesRequestSchema,
+  TestSegmentEvaluationRequestSchema,
+  SetGlobalOptOutRequestSchema,
+  OptOutOfSegmentRequestSchema,
+  OptBackIntoSegmentRequestSchema
+} from "@eide/foir-proto-ts/segments/v1/segments_pb";
+function createSegmentsMethods(client) {
+  return {
+    // ── Queries ──────────────────────────────────────────────
+    async getSegment(id) {
+      const resp = await client.getSegment(
+        create5(GetSegmentRequestSchema, { id })
+      );
+      return resp.segment ?? null;
+    },
+    async getSegmentByKey(key) {
+      const resp = await client.getSegmentByKey(
+        create5(GetSegmentByKeyRequestSchema, { key })
+      );
+      return resp.segment ?? null;
+    },
+    async listSegments(params = {}) {
+      return client.listSegments(
+        create5(ListSegmentsRequestSchema, {
+          isActive: params.isActive,
+          limit: params.limit ?? 50,
+          offset: params.offset ?? 0
+        })
+      );
+    },
+    // ── Mutations ────────────────────────────────────────────
+    async createSegment(params) {
+      const resp = await client.createSegment(
+        create5(CreateSegmentRequestSchema, {
+          key: params.key,
+          name: params.name,
+          description: params.description,
+          rules: params.rules,
+          evaluationMode: params.evaluationMode,
+          isActive: params.isActive
+        })
+      );
+      return resp.segment ?? null;
+    },
+    async updateSegment(params) {
+      const resp = await client.updateSegment(
+        create5(UpdateSegmentRequestSchema, {
+          id: params.id,
+          name: params.name,
+          description: params.description,
+          rules: params.rules,
+          evaluationMode: params.evaluationMode,
+          isActive: params.isActive
+        })
+      );
+      return resp.segment ?? null;
+    },
+    async deleteSegment(id) {
+      const resp = await client.deleteSegment(
+        create5(DeleteSegmentRequestSchema, { id })
+      );
+      return resp.success;
+    },
+    // ── Customer Operations ──────────────────────────────────
+    async getCustomerMemberships(customerId) {
+      return client.getCustomerMemberships(
+        create5(GetCustomerMembershipsRequestSchema, { customerId })
+      );
+    },
+    async previewSegmentRules(rules, sampleSize) {
+      const resp = await client.previewSegmentRules(
+        create5(PreviewSegmentRulesRequestSchema, {
+          rules,
+          sampleSize: sampleSize ?? 10
+        })
+      );
+      return resp.preview ?? null;
+    },
+    async testSegmentEvaluation(segmentId, customerId) {
+      const resp = await client.testSegmentEvaluation(
+        create5(TestSegmentEvaluationRequestSchema, { segmentId, customerId })
+      );
+      return resp.result ?? null;
+    },
+    // ── Opt-out Management ───────────────────────────────────
+    async setGlobalOptOut(customerId, optedOut) {
+      const resp = await client.setGlobalOptOut(
+        create5(SetGlobalOptOutRequestSchema, { customerId, optedOut })
+      );
+      return resp.success;
+    },
+    async optOutOfSegment(customerId, segmentId) {
+      const resp = await client.optOutOfSegment(
+        create5(OptOutOfSegmentRequestSchema, { customerId, segmentId })
+      );
+      return resp.success;
+    },
+    async optBackIntoSegment(customerId, segmentId) {
+      const resp = await client.optBackIntoSegment(
+        create5(OptBackIntoSegmentRequestSchema, { customerId, segmentId })
+      );
+      return resp.success;
+    }
+  };
+}
+
+// src/lib/rpc/experiments.ts
+import { create as create6 } from "@bufbuild/protobuf";
+import {
+  ExperimentStatus,
+  CreateExperimentRequestSchema,
+  GetExperimentRequestSchema,
+  GetExperimentByKeyRequestSchema,
+  ListExperimentsRequestSchema,
+  UpdateExperimentRequestSchema,
+  DeleteExperimentRequestSchema,
+  StartExperimentRequestSchema,
+  PauseExperimentRequestSchema,
+  ResumeExperimentRequestSchema,
+  EndExperimentRequestSchema,
+  GetExperimentStatsRequestSchema,
+  ForceAssignExperimentRequestSchema,
+  RemoveExperimentAssignmentRequestSchema,
+  ApplyExperimentWinnerRequestSchema,
+  GetCustomerAssignmentsRequestSchema,
+  ExperimentVariantSchema
+} from "@eide/foir-proto-ts/experiments/v1/experiments_pb";
+import { ExperimentStatus as ExperimentStatus2 } from "@eide/foir-proto-ts/experiments/v1/experiments_pb";
+var STATUS_TO_PROTO = {
+  draft: ExperimentStatus.DRAFT,
+  running: ExperimentStatus.RUNNING,
+  paused: ExperimentStatus.PAUSED,
+  ended: ExperimentStatus.COMPLETED,
+  completed: ExperimentStatus.COMPLETED
+};
+function createExperimentsMethods(client) {
+  return {
+    // ── Queries ──────────────────────────────────────────────
+    async getExperiment(id) {
+      const resp = await client.getExperiment(
+        create6(GetExperimentRequestSchema, { id })
+      );
+      return resp.experiment ?? null;
+    },
+    async getExperimentByKey(key) {
+      const resp = await client.getExperimentByKey(
+        create6(GetExperimentByKeyRequestSchema, { key })
+      );
+      return resp.experiment ?? null;
+    },
+    async listExperiments(params = {}) {
+      return client.listExperiments(
+        create6(ListExperimentsRequestSchema, {
+          status: params.status ? STATUS_TO_PROTO[params.status] : void 0,
+          isActive: params.isActive,
+          limit: params.limit ?? 50,
+          offset: params.offset ?? 0
+        })
+      );
+    },
+    async getExperimentStats(experimentId) {
+      const resp = await client.getExperimentStats(
+        create6(GetExperimentStatsRequestSchema, { experimentId })
+      );
+      return resp.stats ?? null;
+    },
+    // ── Mutations ────────────────────────────────────────────
+    async createExperiment(params) {
+      const resp = await client.createExperiment(
+        create6(CreateExperimentRequestSchema, {
+          key: params.key,
+          name: params.name,
+          description: params.description,
+          targeting: params.targeting,
+          controlPercent: params.controlPercent,
+          variants: params.variants?.map(
+            (v) => create6(ExperimentVariantSchema, {
+              key: v.key,
+              name: v.name,
+              percent: v.percent
+            })
+          ) ?? []
+        })
+      );
+      return resp.experiment ?? null;
+    },
+    async updateExperiment(params) {
+      const resp = await client.updateExperiment(
+        create6(UpdateExperimentRequestSchema, {
+          id: params.id,
+          name: params.name,
+          description: params.description,
+          targeting: params.targeting,
+          controlPercent: params.controlPercent,
+          variants: params.variants?.map(
+            (v) => create6(ExperimentVariantSchema, {
+              key: v.key,
+              name: v.name,
+              percent: v.percent
+            })
+          )
+        })
+      );
+      return resp.experiment ?? null;
+    },
+    async deleteExperiment(id) {
+      const resp = await client.deleteExperiment(
+        create6(DeleteExperimentRequestSchema, { id })
+      );
+      return resp.success;
+    },
+    // ── Lifecycle ────────────────────────────────────────────
+    async startExperiment(experimentId) {
+      const resp = await client.startExperiment(
+        create6(StartExperimentRequestSchema, { experimentId })
+      );
+      return resp.experiment ?? null;
+    },
+    async pauseExperiment(experimentId) {
+      const resp = await client.pauseExperiment(
+        create6(PauseExperimentRequestSchema, { experimentId })
+      );
+      return resp.experiment ?? null;
+    },
+    async resumeExperiment(experimentId) {
+      const resp = await client.resumeExperiment(
+        create6(ResumeExperimentRequestSchema, { experimentId })
+      );
+      return resp.experiment ?? null;
+    },
+    async endExperiment(experimentId) {
+      const resp = await client.endExperiment(
+        create6(EndExperimentRequestSchema, { experimentId })
+      );
+      return resp.experiment ?? null;
+    },
+    async applyExperimentWinner(experimentId, winnerVariantKey) {
+      const resp = await client.applyExperimentWinner(
+        create6(ApplyExperimentWinnerRequestSchema, {
+          experimentId,
+          winnerVariantKey
+        })
+      );
+      return resp.experiment ?? null;
+    },
+    // ── Assignments ──────────────────────────────────────────
+    async forceAssignExperiment(customerId, experimentId, variantKey) {
+      const resp = await client.forceAssignExperiment(
+        create6(ForceAssignExperimentRequestSchema, {
+          customerId,
+          experimentId,
+          variantKey
+        })
+      );
+      return resp.assignment ?? null;
+    },
+    async removeExperimentAssignment(customerId, experimentId) {
+      const resp = await client.removeExperimentAssignment(
+        create6(RemoveExperimentAssignmentRequestSchema, {
+          customerId,
+          experimentId
+        })
+      );
+      return resp.success;
+    },
+    async getCustomerAssignments(customerId) {
+      const resp = await client.getCustomerAssignments(
+        create6(GetCustomerAssignmentsRequestSchema, { customerId })
+      );
+      return resp.assignments ?? [];
+    }
+  };
+}
+
+// src/lib/rpc/settings.ts
+import { create as create7 } from "@bufbuild/protobuf";
+import {
+  GetSettingsRequestSchema,
+  UpdateSettingRequestSchema,
+  ListContextDimensionsRequestSchema,
+  GetContextDimensionRequestSchema,
+  CreateContextDimensionRequestSchema,
+  UpdateContextDimensionRequestSchema,
+  DeleteContextDimensionRequestSchema,
+  GetContextDimensionValuesRequestSchema,
+  GetCustomerProfileSchemaRequestSchema,
+  GetCustomerProfileRequestSchema,
+  SetCustomerProfileRequestSchema,
+  UpdateCustomerProfileSchemaRequestSchema,
+  GetCustomerResolutionAttributesRequestSchema,
+  GetEditorConfigsRequestSchema,
+  ListEmailActionsRequestSchema,
+  ListResendTemplatesRequestSchema,
+  UpdateEmailActionRequestSchema,
+  ListVariantCatalogRequestSchema,
+  GetVariantCatalogEntryRequestSchema,
+  CreateVariantCatalogEntryRequestSchema,
+  UpdateVariantCatalogEntryRequestSchema,
+  DeleteVariantCatalogEntryRequestSchema,
+  CreateNoteRequestSchema,
+  GetNoteRequestSchema,
+  ListNotesRequestSchema,
+  UpdateNoteRequestSchema,
+  DeleteNoteRequestSchema,
+  ListMyMentionsRequestSchema,
+  UpdateMentionStatusRequestSchema,
+  ListLocalesRequestSchema,
+  GetLocaleRequestSchema,
+  CreateLocaleRequestSchema,
+  UpdateLocaleRequestSchema,
+  DeleteLocaleRequestSchema,
+  GetNavPreferencesRequestSchema,
+  UpdateNavPreferencesRequestSchema,
+  ListRecentlyOpenedRequestSchema,
+  TrackRecentlyOpenedRequestSchema,
+  RemoveRecentlyOpenedRequestSchema,
+  ClearRecentlyOpenedRequestSchema
+} from "@eide/foir-proto-ts/settings/v1/settings_pb";
+function createSettingsMethods(client) {
+  return {
+    // ── Settings ─────────────────────────────────────────────
+    async getSettings(params = {}) {
+      const resp = await client.getSettings(
+        create7(GetSettingsRequestSchema, {
+          category: params.category,
+          key: params.key
+        })
+      );
+      return resp.settings ?? [];
+    },
+    async updateSetting(params) {
+      const resp = await client.updateSetting(
+        create7(UpdateSettingRequestSchema, {
+          key: params.key,
+          value: params.value
+        })
+      );
+      return resp.setting ?? null;
+    },
+    // ── Mentions ─────────────────────────────────────────────
+    async listMyMentions(params = {}) {
+      return client.listMyMentions(
+        create7(ListMyMentionsRequestSchema, {
+          status: params.status ?? [],
+          entityType: params.entityType,
+          limit: params.limit ?? 50,
+          offset: params.offset ?? 0
+        })
+      );
+    },
+    async updateMentionStatus(params) {
+      const resp = await client.updateMentionStatus(
+        create7(UpdateMentionStatusRequestSchema, {
+          mentionId: params.mentionId,
+          status: params.status,
+          completedNote: params.completedNote,
+          dismissReason: params.dismissReason
+        })
+      );
+      return resp.mention ?? null;
+    },
+    // ── Notes ────────────────────────────────────────────────
+    async createNote(params) {
+      const resp = await client.createNote(
+        create7(CreateNoteRequestSchema, {
+          ...params,
+          content: params.content
+        })
+      );
+      return resp.note ?? null;
+    },
+    async getNote(id) {
+      const resp = await client.getNote(create7(GetNoteRequestSchema, { id }));
+      return resp.note ?? null;
+    },
+    async listNotes(params) {
+      return client.listNotes(
+        create7(ListNotesRequestSchema, {
+          entityType: params.entityType,
+          entityId: params.entityId,
+          limit: params.limit ?? 50,
+          offset: params.offset ?? 0
+        })
+      );
+    },
+    async updateNote(params) {
+      const resp = await client.updateNote(
+        create7(UpdateNoteRequestSchema, {
+          id: params.id,
+          content: params.content,
+          isResolved: params.isResolved
+        })
+      );
+      return resp.note ?? null;
+    },
+    async deleteNote(id) {
+      const resp = await client.deleteNote(
+        create7(DeleteNoteRequestSchema, { id })
+      );
+      return resp.success;
+    },
+    // ── Context Dimensions ───────────────────────────────────
+    async listContextDimensions(params = {}) {
+      return client.listContextDimensions(
+        create7(ListContextDimensionsRequestSchema, {
+          search: params.search,
+          limit: params.limit ?? 50,
+          offset: params.offset ?? 0
+        })
+      );
+    },
+    async getContextDimension(id) {
+      const resp = await client.getContextDimension(
+        create7(GetContextDimensionRequestSchema, { id })
+      );
+      return resp.dimension ?? null;
+    },
+    async createContextDimension(params) {
+      const resp = await client.createContextDimension(
+        create7(CreateContextDimensionRequestSchema, params)
+      );
+      return resp.dimension ?? null;
+    },
+    async updateContextDimension(params) {
+      const resp = await client.updateContextDimension(
+        create7(UpdateContextDimensionRequestSchema, params)
+      );
+      return resp.dimension ?? null;
+    },
+    async deleteContextDimension(id) {
+      const resp = await client.deleteContextDimension(
+        create7(DeleteContextDimensionRequestSchema, { id })
+      );
+      return resp.success;
+    },
+    async getContextDimensionValues(dimensionKey, params = {}) {
+      return client.getContextDimensionValues(
+        create7(GetContextDimensionValuesRequestSchema, {
+          dimensionKey,
+          search: params.search,
+          limit: params.limit ?? 50,
+          offset: params.offset ?? 0
+        })
+      );
+    },
+    // ── Customer Profile Schema ──────────────────────────────
+    async getCustomerProfileSchema() {
+      const resp = await client.getCustomerProfileSchema(
+        create7(GetCustomerProfileSchemaRequestSchema, {})
+      );
+      return resp.schema ?? null;
+    },
+    async getCustomerProfile(customerId) {
+      const resp = await client.getCustomerProfile(
+        create7(GetCustomerProfileRequestSchema, { customerId })
+      );
+      return resp.data ?? null;
+    },
+    async setCustomerProfile(params) {
+      const resp = await client.setCustomerProfile(
+        create7(SetCustomerProfileRequestSchema, {
+          customerId: params.customerId,
+          data: params.data
+        })
+      );
+      return resp.success;
+    },
+    async updateCustomerProfileSchema(params) {
+      const resp = await client.updateCustomerProfileSchema(
+        create7(UpdateCustomerProfileSchemaRequestSchema, {
+          fields: params.fields.map((f) => ({
+            id: f.id,
+            key: f.key,
+            type: f.type,
+            label: f.label,
+            required: f.required,
+            helpText: f.helpText,
+            placeholder: f.placeholder,
+            config: f.config
+          })),
+          publicFields: params.publicFields
+        })
+      );
+      return resp.schema ?? null;
+    },
+    async getCustomerResolutionAttributes(customerId) {
+      return client.getCustomerResolutionAttributes(
+        create7(GetCustomerResolutionAttributesRequestSchema, { customerId })
+      );
+    },
+    async getEditorConfigs(modelKey) {
+      const resp = await client.getEditorConfigs(
+        create7(GetEditorConfigsRequestSchema, { modelKey })
+      );
+      return resp.placements ?? [];
+    },
+    // ── Variant Catalog ──────────────────────────────────────
+    async listVariantCatalog(params = {}) {
+      return client.listVariantCatalog(
+        create7(ListVariantCatalogRequestSchema, {
+          isActive: params.isActive,
+          limit: params.limit ?? 50,
+          offset: params.offset ?? 0
+        })
+      );
+    },
+    async getVariantCatalogEntry(id) {
+      const resp = await client.getVariantCatalogEntry(
+        create7(GetVariantCatalogEntryRequestSchema, { id })
+      );
+      return resp.entry ?? null;
+    },
+    async createVariantCatalogEntry(params) {
+      const resp = await client.createVariantCatalogEntry(
+        create7(CreateVariantCatalogEntryRequestSchema, {
+          key: params.key,
+          name: params.name,
+          description: params.description,
+          targetingRules: params.targetingRules,
+          priority: params.priority,
+          isDefault: params.isDefault,
+          isActive: params.isActive
+        })
+      );
+      return resp.entry ?? null;
+    },
+    async updateVariantCatalogEntry(params) {
+      const resp = await client.updateVariantCatalogEntry(
+        create7(UpdateVariantCatalogEntryRequestSchema, {
+          id: params.id,
+          name: params.name,
+          description: params.description,
+          targetingRules: params.targetingRules,
+          priority: params.priority,
+          isDefault: params.isDefault,
+          isActive: params.isActive
+        })
+      );
+      return resp.entry ?? null;
+    },
+    async deleteVariantCatalogEntry(id) {
+      const resp = await client.deleteVariantCatalogEntry(
+        create7(DeleteVariantCatalogEntryRequestSchema, { id })
+      );
+      return resp.success;
+    },
+    // ── Locales ──────────────────────────────────────────────
+    async listLocales(params = {}) {
+      return client.listLocales(
+        create7(ListLocalesRequestSchema, {
+          includeInactive: params.includeInactive,
+          limit: params.limit ?? 50,
+          offset: params.offset ?? 0
+        })
+      );
+    },
+    async getLocale(id) {
+      const resp = await client.getLocale(
+        create7(GetLocaleRequestSchema, { id })
+      );
+      return resp.locale ?? null;
+    },
+    async createLocale(params) {
+      const resp = await client.createLocale(
+        create7(CreateLocaleRequestSchema, {
+          locale: params.locale,
+          displayName: params.displayName,
+          nativeName: params.nativeName,
+          isDefault: params.isDefault,
+          isRtl: params.isRtl,
+          fallbackLocale: params.fallbackLocale
+        })
+      );
+      return resp.locale ?? null;
+    },
+    async updateLocale(params) {
+      const resp = await client.updateLocale(
+        create7(UpdateLocaleRequestSchema, {
+          id: params.id,
+          displayName: params.displayName,
+          nativeName: params.nativeName,
+          isDefault: params.isDefault,
+          isActive: params.isActive,
+          isRtl: params.isRtl,
+          fallbackLocale: params.fallbackLocale
+        })
+      );
+      return resp.locale ?? null;
+    },
+    async deleteLocale(id) {
+      const resp = await client.deleteLocale(
+        create7(DeleteLocaleRequestSchema, { id })
+      );
+      return resp.success;
+    },
+    // ── Nav Preferences ─────────────────────────────────────
+    async getNavPreferences() {
+      const resp = await client.getNavPreferences(
+        create7(GetNavPreferencesRequestSchema, {})
+      );
+      return resp.preferences ?? null;
+    },
+    async updateNavPreferences(params) {
+      const resp = await client.updateNavPreferences(
+        create7(UpdateNavPreferencesRequestSchema, {
+          preferences: params.preferences ? {
+            favoriteProjects: params.preferences.favoriteProjects,
+            favoriteNavItems: params.preferences.favoriteNavItems,
+            collapsedSections: params.preferences.collapsedSections,
+            navItemOrder: params.preferences.navItemOrder
+          } : void 0,
+          toggleProjectId: params.toggleProjectId,
+          toggleNavItem: params.toggleNavItem,
+          toggleSection: params.toggleSection
+        })
+      );
+      return resp.preferences ?? null;
+    },
+    // ── Recently Opened ─────────────────────────────────────
+    async listRecentlyOpened(limit) {
+      const resp = await client.listRecentlyOpened(
+        create7(ListRecentlyOpenedRequestSchema, {
+          limit: limit ?? 20
+        })
+      );
+      return resp.items ?? [];
+    },
+    async trackRecentlyOpened(params) {
+      const resp = await client.trackRecentlyOpened(
+        create7(TrackRecentlyOpenedRequestSchema, {
+          type: params.type,
+          id: params.id,
+          label: params.label,
+          path: params.path
+        })
+      );
+      return resp.success;
+    },
+    async removeRecentlyOpened(params) {
+      const resp = await client.removeRecentlyOpened(
+        create7(RemoveRecentlyOpenedRequestSchema, {
+          type: params.type,
+          id: params.id
+        })
+      );
+      return resp.success;
+    },
+    async clearRecentlyOpened() {
+      const resp = await client.clearRecentlyOpened(
+        create7(ClearRecentlyOpenedRequestSchema, {})
+      );
+      return resp.success;
+    },
+    // ── Email Actions ──────────────────────────────────────────
+    async listEmailActions(params = {}) {
+      return client.listEmailActions(
+        create7(ListEmailActionsRequestSchema, {
+          limit: params.limit ?? 50,
+          offset: params.offset ?? 0
+        })
+      );
+    },
+    async updateEmailAction(params) {
+      const resp = await client.updateEmailAction(
+        create7(UpdateEmailActionRequestSchema, {
+          key: params.key,
+          resendTemplateId: params.resendTemplateId,
+          defaultFrom: params.defaultFrom,
+          defaultSubject: params.defaultSubject,
+          customData: params.customData,
+          isActive: params.isActive
+        })
+      );
+      return resp.action ?? null;
+    },
+    async listResendTemplates() {
+      const resp = await client.listResendTemplates(
+        create7(ListResendTemplatesRequestSchema, {})
+      );
+      return resp.templates ?? [];
+    }
+  };
+}
+
+// src/lib/rpc/storage.ts
+import { create as create8 } from "@bufbuild/protobuf";
 import {
-  IdentityService,
-  ModelsService,
-  RecordsService,
-  ConfigsService,
-  SegmentsService,
-  ExperimentsService,
-  SettingsService,
-  StorageService
-} from "@foir/connect-clients/services";
-import { createIdentityMethods } from "@foir/connect-clients/identity";
-import { createModelsMethods } from "@foir/connect-clients/models";
-import { createRecordsMethods } from "@foir/connect-clients/records";
-import { createConfigsMethods } from "@foir/connect-clients/configs";
-import { createSegmentsMethods } from "@foir/connect-clients/segments";
-import { createExperimentsMethods } from "@foir/connect-clients/experiments";
-import { createSettingsMethods } from "@foir/connect-clients/settings";
-import { createStorageMethods } from "@foir/connect-clients/storage";
+  CreateFileUploadRequestSchema,
+  ConfirmFileUploadRequestSchema,
+  GetFileRequestSchema,
+  ListFilesRequestSchema,
+  GetStorageUsageRequestSchema,
+  UpdateFileRequestSchema,
+  UpdateFileMetadataRequestSchema,
+  DeleteFileRequestSchema,
+  PermanentlyDeleteFileRequestSchema,
+  RestoreFileRequestSchema,
+  TrackFileUsageRequestSchema,
+  RemoveFileUsageRequestSchema,
+  CleanupOrphanedFilesRequestSchema
+} from "@eide/foir-proto-ts/storage/v1/storage_pb";
+function createStorageMethods(client) {
+  return {
+    async createFileUpload(params) {
+      return client.createFileUpload(
+        create8(CreateFileUploadRequestSchema, {
+          filename: params.filename,
+          mimeType: params.mimeType,
+          size: BigInt(params.size),
+          folder: params.folder
+        })
+      );
+    },
+    async confirmFileUpload(uploadId) {
+      const resp = await client.confirmFileUpload(
+        create8(ConfirmFileUploadRequestSchema, { uploadId })
+      );
+      return resp.file ?? null;
+    },
+    async getFile(id) {
+      const resp = await client.getFile(create8(GetFileRequestSchema, { id }));
+      return resp.file ?? null;
+    },
+    async listFiles(params) {
+      return client.listFiles(
+        create8(ListFilesRequestSchema, {
+          folder: params.folder,
+          mimeType: params.mimeType,
+          search: params.search,
+          includeDeleted: params.includeDeleted ?? false,
+          limit: params.limit ?? 50,
+          offset: params.offset ?? 0
+        })
+      );
+    },
+    async getStorageUsage() {
+      const resp = await client.getStorageUsage(
+        create8(GetStorageUsageRequestSchema, {})
+      );
+      return resp.usage ?? null;
+    },
+    async updateFile(params) {
+      const resp = await client.updateFile(
+        create8(UpdateFileRequestSchema, {
+          id: params.id,
+          filename: params.filename,
+          folder: params.folder,
+          tags: params.tags ?? []
+        })
+      );
+      return resp.file ?? null;
+    },
+    async updateFileMetadata(params) {
+      const resp = await client.updateFileMetadata(
+        create8(UpdateFileMetadataRequestSchema, {
+          id: params.id,
+          altText: params.altText,
+          caption: params.caption,
+          description: params.description
+        })
+      );
+      return resp.file ?? null;
+    },
+    async deleteFile(id) {
+      const resp = await client.deleteFile(
+        create8(DeleteFileRequestSchema, { id })
+      );
+      return resp.success;
+    },
+    async permanentlyDeleteFile(id) {
+      const resp = await client.permanentlyDeleteFile(
+        create8(PermanentlyDeleteFileRequestSchema, { id })
+      );
+      return resp.success;
+    },
+    async restoreFile(id) {
+      const resp = await client.restoreFile(
+        create8(RestoreFileRequestSchema, { id })
+      );
+      return resp.file ?? null;
+    },
+    async trackFileUsage(fileId, entityType) {
+      const resp = await client.trackFileUsage(
+        create8(TrackFileUsageRequestSchema, { fileId, entityType })
+      );
+      return resp.file ?? null;
+    },
+    async removeFileUsage(fileId, entityType) {
+      const resp = await client.removeFileUsage(
+        create8(RemoveFileUsageRequestSchema, { fileId, entityType })
+      );
+      return resp.success;
+    },
+    async cleanupOrphanedFiles(params) {
+      return client.cleanupOrphanedFiles(
+        create8(CleanupOrphanedFilesRequestSchema, {
+          orphanThresholdDays: params?.orphanThresholdDays ?? 30,
+          dryRun: params?.dryRun ?? false,
+          limit: params?.limit ?? 100
+        })
+      );
+    }
+  };
+}
+
+// src/lib/client.ts
+import { GraphQLClient } from "graphql-request";
 async function createPlatformClient(options) {
   const apiUrl = getApiUrl(options);
   const headers = {};
@@ -503,16 +2717,16 @@ async function createPlatformClient(options) {
     interceptors: [authInterceptor]
   });
   return {
-    identity: createIdentityMethods(createClient(IdentityService, transport)),
-    models: createModelsMethods(createClient(ModelsService, transport)),
-    records: createRecordsMethods(createClient(RecordsService, transport)),
-    configs: createConfigsMethods(createClient(ConfigsService, transport)),
-    segments: createSegmentsMethods(createClient(SegmentsService, transport)),
+    identity: createIdentityMethods(createRpcClient(IdentityService2, transport)),
+    models: createModelsMethods(createRpcClient(ModelsService2, transport)),
+    records: createRecordsMethods(createRpcClient(RecordsService2, transport)),
+    configs: createConfigsMethods(createRpcClient(ConfigsService2, transport)),
+    segments: createSegmentsMethods(createRpcClient(SegmentsService2, transport)),
     experiments: createExperimentsMethods(
-      createClient(ExperimentsService, transport)
+      createRpcClient(ExperimentsService2, transport)
     ),
-    settings: createSettingsMethods(createClient(SettingsService, transport)),
-    storage: createStorageMethods(createClient(StorageService, transport))
+    settings: createSettingsMethods(createRpcClient(SettingsService2, transport)),
+    storage: createStorageMethods(createRpcClient(StorageService2, transport))
   };
 }
 function createPlatformClientWithHeaders(apiUrl, headers) {
@@ -528,16 +2742,16 @@ function createPlatformClientWithHeaders(apiUrl, headers) {
     interceptors: [authInterceptor]
   });
   return {
-    identity: createIdentityMethods(createClient(IdentityService, transport)),
-    models: createModelsMethods(createClient(ModelsService, transport)),
-    records: createRecordsMethods(createClient(RecordsService, transport)),
-    configs: createConfigsMethods(createClient(ConfigsService, transport)),
-    segments: createSegmentsMethods(createClient(SegmentsService, transport)),
+    identity: createIdentityMethods(createRpcClient(IdentityService2, transport)),
+    models: createModelsMethods(createRpcClient(ModelsService2, transport)),
+    records: createRecordsMethods(createRpcClient(RecordsService2, transport)),
+    configs: createConfigsMethods(createRpcClient(ConfigsService2, transport)),
+    segments: createSegmentsMethods(createRpcClient(SegmentsService2, transport)),
     experiments: createExperimentsMethods(
-      createClient(ExperimentsService, transport)
+      createRpcClient(ExperimentsService2, transport)
     ),
-    settings: createSettingsMethods(createClient(SettingsService, transport)),
-    storage: createStorageMethods(createClient(StorageService, transport))
+    settings: createSettingsMethods(createRpcClient(SettingsService2, transport)),
+    storage: createStorageMethods(createRpcClient(StorageService2, transport))
   };
 }
 async function getStorageAuth(options) {
@@ -872,7 +3086,9 @@ function registerWhoamiCommand(program2, globalOpts) {
 import { promises as fs2 } from "fs";
 import { basename } from "path";
 import chalk3 from "chalk";
-import { createStorageClient } from "@foir/connect-clients/storage";
+import { createClient } from "@connectrpc/connect";
+import { createConnectTransport as createConnectTransport2 } from "@connectrpc/connect-node";
+import { StorageService as StorageService3 } from "@eide/foir-proto-ts/storage/v1/storage_pb";
 
 // src/lib/input.ts
 import inquirer2 from "inquirer";
@@ -966,11 +3182,19 @@ function guessMimeType(filename) {
 function getStorageUrl() {
   return process.env.FOIR_STORAGE_URL ?? "https://storage.foir.dev";
 }
-function createClient2(getToken) {
-  return createStorageClient({
+function createStorageRpcClient(getToken) {
+  const transport = createConnectTransport2({
     baseUrl: getStorageUrl(),
-    getAuthToken: getToken
+    httpVersion: "1.1",
+    interceptors: [
+      (next) => async (req) => {
+        const token = await getToken();
+        if (token) req.header.set("Authorization", `Bearer ${token}`);
+        return next(req);
+      }
+    ]
   });
+  return createStorageMethods(createClient(StorageService3, transport));
 }
 function registerMediaCommands(program2, globalOpts) {
   const media = program2.command("media").description("Media file operations");
@@ -980,7 +3204,7 @@ function registerMediaCommands(program2, globalOpts) {
       async (filepath, flags) => {
         const opts = globalOpts();
         const { getToken } = await getStorageAuth(opts);
-        const storage = createClient2(getToken);
+        const storage = createStorageRpcClient(getToken);
         const fileBuffer = await fs2.readFile(filepath);
         const filename = basename(filepath);
         const mimeType = guessMimeType(filename);
@@ -1021,7 +3245,7 @@ function registerMediaCommands(program2, globalOpts) {
       async (flags) => {
         const opts = globalOpts();
         const { getToken } = await getStorageAuth(opts);
-        const storage = createClient2(getToken);
+        const storage = createStorageRpcClient(getToken);
         const result = await storage.listFiles({
           folder: flags.folder,
           mimeType: flags["mime-type"] ?? flags.mimeType,
@@ -1063,7 +3287,7 @@ function registerMediaCommands(program2, globalOpts) {
     withErrorHandler(globalOpts, async (id) => {
       const opts = globalOpts();
       const { getToken } = await getStorageAuth(opts);
-      const storage = createClient2(getToken);
+      const storage = createStorageRpcClient(getToken);
       const file = await storage.getFile(id);
       formatOutput(file, opts);
     })
@@ -1072,7 +3296,7 @@ function registerMediaCommands(program2, globalOpts) {
     withErrorHandler(globalOpts, async () => {
       const opts = globalOpts();
       const { getToken } = await getStorageAuth(opts);
-      const storage = createClient2(getToken);
+      const storage = createStorageRpcClient(getToken);
       const usage = await storage.getStorageUsage();
       if (opts.json || opts.jsonl) {
         formatOutput(usage, opts);
@@ -1091,7 +3315,7 @@ function registerMediaCommands(program2, globalOpts) {
       async (id, flags) => {
         const opts = globalOpts();
         const { getToken } = await getStorageAuth(opts);
-        const storage = createClient2(getToken);
+        const storage = createStorageRpcClient(getToken);
         const file = await storage.updateFile({
           id,
           filename: flags.filename,
@@ -1112,7 +3336,7 @@ function registerMediaCommands(program2, globalOpts) {
       async (id, flags) => {
         const opts = globalOpts();
         const { getToken } = await getStorageAuth(opts);
-        const storage = createClient2(getToken);
+        const storage = createStorageRpcClient(getToken);
         const file = await storage.updateFileMetadata({
           id,
           altText: flags.altText ?? flags["alt-text"],
@@ -1140,7 +3364,7 @@ function registerMediaCommands(program2, globalOpts) {
           return;
         }
         const { getToken } = await getStorageAuth(opts);
-        const storage = createClient2(getToken);
+        const storage = createStorageRpcClient(getToken);
         if (flags.permanent) {
           await storage.permanentlyDeleteFile(id);
           success("Permanently deleted file");
@@ -1155,7 +3379,7 @@ function registerMediaCommands(program2, globalOpts) {
     withErrorHandler(globalOpts, async (id) => {
       const opts = globalOpts();
       const { getToken } = await getStorageAuth(opts);
-      const storage = createClient2(getToken);
+      const storage = createStorageRpcClient(getToken);
       const file = await storage.restoreFile(id);
       if (opts.json || opts.jsonl) {
         formatOutput(file, opts);
@@ -2258,7 +4482,7 @@ import { readdirSync } from "fs";
 import { resolve as resolve5 } from "path";
 import chalk9 from "chalk";
 
-// ../command-registry/src/command-map.ts
+// src/command-registry/command-map.ts
 var COMMANDS = [
   // =========================================================================
   // MODELS
@@ -2433,6 +4657,15 @@ var COMMANDS = [
     scalarResult: true,
     successMessage: "Unpublished record"
   },
+  {
+    group: "records",
+    name: "cancel-schedule",
+    description: "Cancel a scheduled publish or unpublish",
+    operation: "cancelScheduledRecordPublish",
+    operationType: "mutation",
+    positionalArgs: [{ name: "versionId", graphqlArg: "versionId", description: "Version ID" }],
+    successMessage: "Cancelled scheduled publish for version {versionId}"
+  },
   {
     group: "records",
     name: "duplicate",
@@ -2489,6 +4722,104 @@ var COMMANDS = [
     successMessage: "Created variant"
   },
   // =========================================================================
+  // ROLLOUTS
+  // =========================================================================
+  {
+    group: "rollouts",
+    name: "list",
+    description: "List rollouts",
+    operation: "listPublishBatches",
+    operationType: "query",
+    columns: [
+      { key: "id", header: "ID", width: 28 },
+      { key: "name", header: "Name", width: 24 },
+      { key: "status", header: "Status", width: 16 },
+      { key: "itemCount", header: "Items", width: 6 },
+      { key: "completedCount", header: "Done", width: 6 },
+      { key: "scheduledAt", header: "Scheduled", width: 12, format: "timeAgo" },
+      { key: "createdAt", header: "Created", width: 12, format: "timeAgo" }
+    ]
+  },
+  {
+    group: "rollouts",
+    name: "get",
+    description: "Get a rollout",
+    operation: "getPublishBatch",
+    operationType: "query",
+    positionalArgs: [{ name: "id", graphqlArg: "id", description: "Rollout ID" }]
+  },
+  {
+    group: "rollouts",
+    name: "create",
+    description: "Create a rollout",
+    operation: "createPublishBatch",
+    operationType: "mutation",
+    acceptsInput: true,
+    successMessage: "Created rollout {name}"
+  },
+  {
+    group: "rollouts",
+    name: "update",
+    description: "Update a rollout",
+    operation: "updatePublishBatch",
+    operationType: "mutation",
+    positionalArgs: [{ name: "id", graphqlArg: "id", description: "Rollout ID" }],
+    acceptsInput: true,
+    successMessage: "Updated rollout"
+  },
+  {
+    group: "rollouts",
+    name: "cancel",
+    description: "Cancel a rollout",
+    operation: "cancelPublishBatch",
+    operationType: "mutation",
+    positionalArgs: [{ name: "id", graphqlArg: "id", description: "Rollout ID" }],
+    requiresConfirmation: true,
+    scalarResult: true,
+    successMessage: "Cancelled rollout"
+  },
+  {
+    group: "rollouts",
+    name: "rollback",
+    description: "Rollback a completed rollout",
+    operation: "rollbackPublishBatch",
+    operationType: "mutation",
+    positionalArgs: [{ name: "id", graphqlArg: "id", description: "Rollout ID" }],
+    requiresConfirmation: true,
+    scalarResult: true,
+    successMessage: "Rolled back rollout"
+  },
+  {
+    group: "rollouts",
+    name: "retry",
+    description: "Retry failed items in a rollout",
+    operation: "retryFailedBatchItems",
+    operationType: "mutation",
+    positionalArgs: [{ name: "id", graphqlArg: "id", description: "Rollout ID" }],
+    scalarResult: true,
+    successMessage: "Retrying failed items in rollout"
+  },
+  {
+    group: "rollouts",
+    name: "add-items",
+    description: "Add version IDs to a rollout",
+    operation: "addItemsToPublishBatch",
+    operationType: "mutation",
+    positionalArgs: [{ name: "id", graphqlArg: "id", description: "Rollout ID" }],
+    acceptsInput: true,
+    successMessage: "Added items to rollout"
+  },
+  {
+    group: "rollouts",
+    name: "remove-items",
+    description: "Remove version IDs from a rollout",
+    operation: "removeItemsFromPublishBatch",
+    operationType: "mutation",
+    positionalArgs: [{ name: "id", graphqlArg: "id", description: "Rollout ID" }],
+    acceptsInput: true,
+    successMessage: "Removed items from rollout"
+  },
+  // =========================================================================
   // LOCALES
   // =========================================================================
   {
@@ -3197,6 +5528,7 @@ var COMMANDS = [
     description: "List hook deliveries",
     operation: "hookDeliveries",
     operationType: "query",
+    positionalArgs: [{ name: "hookId", graphqlArg: "hookId", description: "Hook ID" }],
     columns: [
       { key: "id", header: "ID", width: 28 },
       { key: "event", header: "Event", width: 16 },
@@ -3600,8 +5932,19 @@ var COMMANDS = [
   }
 ];
 
+// src/command-registry/schema-engine.ts
+import {
+  buildSchema,
+  isObjectType,
+  isInputObjectType,
+  isListType,
+  isNonNullType,
+  isScalarType,
+  isEnumType
+} from "graphql";
+
 // src/commands/register-commands.ts
-import { RecordType } from "@foir/connect-clients/records";
+import { RecordType as RecordType2 } from "@eide/foir-proto-ts/records/v1/records_pb";
 function buildDispatchTable() {
   return {
     // ── Models ──────────────────────────────────────────────────
@@ -4247,7 +6590,7 @@ function registerDynamicCommands(program2, globalOpts) {
             } else {
               try {
                 const record = await client.records.getRecord(versionIdValue);
-                if (record?.recordType === RecordType.RECORD && record?.currentVersionId) {
+                if (record?.recordType === RecordType2.RECORD && record?.currentVersionId) {
                   variables.versionId = record.currentVersionId;
                 }
               } catch {