@ultrst-armada/kloks 1.8.0 → 1.9.0

package/.krusbl-release-attestation.json

@@ -1,8 +1,8 @@
 {
   "schema": 1,
   "packageName": "@ultrst-armada/kloks",
-  "version": "1.8.0",
-  "sourceCommit": "d364f4fd5a705bea93c4fb0a93ff9740c1050f49",
+  "version": "1.9.0",
+  "sourceCommit": "b6205d2c4f27f354324b4029676d614418fae89d",
   "releaseWorkflow": "npm Release",
-  "workflowRunId": "40208606705"
+  "workflowRunId": "40212539594"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ultrst-armada/kloks",
-  "version": "1.8.0",
+  "version": "1.9.0",
   "private": false,
   "publishConfig": {
     "access": "public",

package/packages/backend/dist/auth/index.js

@@ -3,7 +3,7 @@ import {
   BaseAccountProvider,
   LocalAccountProvider,
   PasswordHasher
-} from "../chunk-HT2SEDHD.js";
+} from "../chunk-W6JNJD3Q.js";
 import {
   CanonicalAuthClient,
   RateLimiter,
@@ -11,7 +11,7 @@ import {
   createCanonicalAuthClient,
   loginSystemUser,
   resolveUserFromToken
-} from "../chunk-M4GSR46Y.js";
+} from "../chunk-WTBAG4AV.js";
 export {
   AdminGuard,
   BaseAccountProvider,

package/packages/backend/dist/{chunk-BPFZCDS4.js → chunk-UMEO6XS4.js}

@@ -1,10 +1,16 @@
+import {
+  workspaceGraphService
+} from "./chunk-VKSGYMAH.js";
 import {
   getSrklAccounts,
   srklListBackblazeBuckets
 } from "./chunk-XHADDA75.js";
 import {
-  workspaceGraphService
-} from "./chunk-5RXXC6GE.js";
+  StorageAdapterFactory
+} from "./chunk-SHZAQTIT.js";
+import {
+  b2ListBuckets
+} from "./chunk-4QEMALXF.js";
 import {
   formatCanonicalWorkspaceFolderName,
   sanitizeWorkspaceName
@@ -19,18 +25,12 @@ import {
 import {
   queryUnifiedDb
 } from "./chunk-VAFCR2MS.js";
-import {
-  b2ListBuckets
-} from "./chunk-4QEMALXF.js";
-import {
-  StorageAdapterFactory
-} from "./chunk-SHZAQTIT.js";
 import {
   RateLimiter,
   SessionManager,
   loginSystemUser,
   resolveUserFromToken
-} from "./chunk-M4GSR46Y.js";
+} from "./chunk-WTBAG4AV.js";
 import {
   createService,
   createServiceDefinition

package/packages/backend/dist/{chunk-HT2SEDHD.js → chunk-W6JNJD3Q.js}

@@ -1,7 +1,7 @@
 import {
   RateLimiter,
   SessionManager
-} from "./chunk-M4GSR46Y.js";
+} from "./chunk-WTBAG4AV.js";
 
 // src/auth/PasswordHasher.ts
 var bcrypt = null;

package/packages/backend/dist/{chunk-M4GSR46Y.js → chunk-WTBAG4AV.js}

@@ -180,9 +180,11 @@ async function resolveUserFromToken(tokenOrUserId, _queryDb, env) {
   if (!tokenOrUserId) return null;
   try {
     const client = createCanonicalAuthClient(requireAuthBaseUrl(env));
-    const session = await client.getSession(
-      tokenOrUserId.startsWith("Bearer ") ? `better-auth.session_token=${tokenOrUserId.slice(7).trim()}` : void 0
-    );
+    const credential = tokenOrUserId.trim();
+    if (!credential) return null;
+    const token = credential.replace(/^Bearer[ \t]+/i, "").trim();
+    if (!token) return null;
+    const session = await client.getSession(`better-auth.session_token=${token}`);
     if (!session?.user) return null;
     return {
       ...session.user,

package/packages/backend/dist/index.d.ts

@@ -765,6 +765,7 @@ declare function buildProjectObservability(projects: any[], deployments: any[],
     fastDataTransferFormatted: string;
     middlewareInvocations: number;
     middlewareInvocationsFormatted: string;
+    latestDeploymentId: any;
     latestDeploymentUrl: string;
     latestDeploymentStatus: string;
     latestDeploymentCreatedAt: string;
@@ -780,8 +781,46 @@ declare function buildProjectsList(observability: any[]): {
     domain: any;
     domains: any;
     updatedAt: any;
+    deploymentId: any;
 }[];
 
+/**
+ * Provider deployment-control operations.
+ *
+ * Vercel: pauses/resumes a project's production service.
+ * Cloudflare Pages: disables/enables automatic production and preview deployments.
+ */
+type CloudflarePagesPreviewSetting = 'all' | 'none' | 'custom';
+interface CloudflarePagesPauseState {
+    productionDeploymentsEnabled: boolean;
+    previewDeploymentSetting: CloudflarePagesPreviewSetting;
+}
+interface DeploymentControlResult {
+    success: true;
+    provider: 'VERCEL' | 'CLOUDFLARE';
+    projectId: string;
+    controlState: 'ACTIVE' | 'PAUSED';
+    pauseState?: CloudflarePagesPauseState;
+}
+interface CredentialPayload {
+    token?: string;
+    apiToken?: string;
+    accessToken?: string;
+    teamId?: string;
+    accountId?: string;
+    cfAccountId?: string;
+    accountTag?: string;
+    authKey?: string;
+    globalApiKey?: string;
+    authEmail?: string;
+    email?: string;
+    credentials?: Record<string, any>;
+}
+declare function pauseVercelProject(projectId: string, payload?: CredentialPayload, userId?: string, env?: Record<string, unknown>): Promise<DeploymentControlResult>;
+declare function resumeVercelProject(projectId: string, payload?: CredentialPayload, userId?: string, env?: Record<string, unknown>): Promise<DeploymentControlResult>;
+declare function pauseCloudflarePagesProject(projectName: string, payload?: CredentialPayload, userId?: string, env?: Record<string, unknown>): Promise<DeploymentControlResult>;
+declare function resumeCloudflarePagesProject(projectName: string, pauseState: CloudflarePagesPauseState, payload?: CredentialPayload, userId?: string, env?: Record<string, unknown>): Promise<DeploymentControlResult>;
+
 declare function createWavBuffer(sampleRate: number, numChannels: number, samples: Float32Array[]): Buffer;
 
 declare function ensureGlobalSamples(globalSamplesDir: string): Promise<void>;
@@ -1638,4 +1677,4 @@ declare function resolveSystemDatabaseUrl(env?: Record<string, string | undefine
  */
 declare function tryResolveSystemDatabaseUrl(env?: Record<string, string | undefined>): string | null;
 
-export { type AssetChannelType, type AssetDataType, type AssetFolderInfo, type AssetPoolItem, type AssetPoolScope, type B2AuthData, type BackendFacade, BaseDataProvider, BaseResourceFetcher, type CloudflareObservability, type CloudflareProjectItem, CloudflareResourceFetcher, type CloudflareUsageMetrics, type CredentialEntry, type CredentialManifest, type Deployment, type FunctionSet, FunctionalityTable, GRAPHS_ROOT, type IDataProvider, LEGACY_PROJECTS_ROOT, type OrchestrationFn, PROJECTS_ROOT, type ProjectMetadata, type PublicRouteRecord, type QueryFilter, ResourceFetcherRegistry, type Runtime, SAMPLES_GLOBAL_ROOT, SUPPORTED_AUDIO_EXTS, SUPPORTED_MIDI_EXTS, type ServerAudioSampleItem, type ServiceFacade, type ServiceRegistryRecord, type SortOrder, type SrklB2Account, SrklStorageService, type SyncFileResult, type UnifiedQueryResult, type UnifiedResourceMetricItem, type UnifiedResourceMetrics, VercelResourceFetcher, WORKSPACE_ASSETS_ROOT, WORKSPACE_ROOT, type WorkingWorkspaceConfig, type WorkspaceFolderResolution, type WorkspaceStorageConfig, b2DeleteFileVersion, b2DeleteFolder, buildProjectObservability, buildProjectsList, cleanDbUrl, computeDeploymentFinalWeight, computeUsageWeightScore, configureStarterProjectTemplate, createAssetSubfolder, createCredential, createGraphAssetFolder, createGraphAssetFolder as createGraphAssetSubfolder, createGraphPackage, createWavBuffer, createWorkspace, createWorkspaceGraph, decryptSecretFromBlob, deleteAssetFromGraph, deleteAssetFromPool, deleteCredential, deleteGlobalSample, deleteGraphPackage, deleteProject, deleteProjectSample, deleteRoute, deleteWorkspace, deleteWorkspaceFile, deleteWorkspaceFolder, deleteWorkspaceGraph, encryptSecretToBlob, ensureAssetPoolDirectories, ensureGlobalSamples, ensureGraphAssetDirectories, ensureProjectAssets, ensureProjectsRoot, ensureWorkspaceStructure, exportEncryptedCredentials, fetchCloudflareData, fetchVercelData, findUserWorkspace, findWorkspaceRecord, formatRelativeCreated, getAllRoutes, getAssetPoolLocationPath, getAssetPoolPublicUrl, getB2BucketId, getConnectedDeploymentNode, getConnectedWeightModifiers, getCredential, getDefaultWorkingWorkspaceDir, getExecutions, getGatewayConfig, getGraphPackageById, getPrimarySrklDeploymentUrl as getPrimarySrklCoreDeploymentUrl, getProjectById, getPublicRouteByPath, getPublicRoutes, getSrklAccounts as getSrklCoreAccounts, getSrklStatus, getUnifiedDbUrl, getUsers, getWeightModifierScore, getWorkingWorkspaceConfig, getWorkingWorkspaceDir, getWorkspaceFolderKey, getWorkspaceFolderPrefix, getWorkspaceGraph, getWorkspaceStorageDetails, getWorkspaces, importEncryptedCredentials, importGraphDependency, initGlobalSamplesDirectory, isB2Workspace, listAllGraphPackages, listAllProjects, listBackblazeBuckets, listCredentials, listGlobalSamples, listProjectSamples, listWorkspaceFiles, listWorkspaceGraphs, loadCredentialManifest, loadWorkspaceData, loginUser, matchGatewayIngress, matchGatewayIngressAsync, queryUnifiedDb, readWorkspaceFile, recordExecution, removeGraphDependency, renameAppInWorkspaceData, resolveDynamicRouteFromDb, resolveSystemDatabaseUrl, resolveWorkspaceConnection, resolveWorkspaceDir, saveAssetToGraph, saveAssetToPool, saveCredentialManifest, saveGlobalSample, saveGraphPackage, saveProject, saveProjectSample, saveWorkspaceData, saveWorkspaceGraph, scanAssetPool, scanGraphAssets, seedDefaultAssets, seedStarterGraphAssets, serverPublicRoutes, setServerPublicRoutes, setWorkingWorkspaceConfig, srklListBackblazeBuckets as srklCoreListBackblazeBuckets, syncWorkspace, syncWorkspaceCreateToBucket, syncWorkspaceDataToBucket, syncWorkspaceDeleteToBucket, tryResolveSystemDatabaseUrl, updateCredential, updateWorkspace, upsertRoute, validateServiceDefinition, writeWorkspaceFile };
+export { type AssetChannelType, type AssetDataType, type AssetFolderInfo, type AssetPoolItem, type AssetPoolScope, type B2AuthData, type BackendFacade, BaseDataProvider, BaseResourceFetcher, type CloudflareObservability, type CloudflarePagesPauseState, type CloudflarePagesPreviewSetting, type CloudflareProjectItem, CloudflareResourceFetcher, type CloudflareUsageMetrics, type CredentialEntry, type CredentialManifest, type Deployment, type DeploymentControlResult, type FunctionSet, FunctionalityTable, GRAPHS_ROOT, type IDataProvider, LEGACY_PROJECTS_ROOT, type OrchestrationFn, PROJECTS_ROOT, type ProjectMetadata, type PublicRouteRecord, type QueryFilter, ResourceFetcherRegistry, type Runtime, SAMPLES_GLOBAL_ROOT, SUPPORTED_AUDIO_EXTS, SUPPORTED_MIDI_EXTS, type ServerAudioSampleItem, type ServiceFacade, type ServiceRegistryRecord, type SortOrder, type SrklB2Account, SrklStorageService, type SyncFileResult, type UnifiedQueryResult, type UnifiedResourceMetricItem, type UnifiedResourceMetrics, VercelResourceFetcher, WORKSPACE_ASSETS_ROOT, WORKSPACE_ROOT, type WorkingWorkspaceConfig, type WorkspaceFolderResolution, type WorkspaceStorageConfig, b2DeleteFileVersion, b2DeleteFolder, buildProjectObservability, buildProjectsList, cleanDbUrl, computeDeploymentFinalWeight, computeUsageWeightScore, configureStarterProjectTemplate, createAssetSubfolder, createCredential, createGraphAssetFolder, createGraphAssetFolder as createGraphAssetSubfolder, createGraphPackage, createWavBuffer, createWorkspace, createWorkspaceGraph, decryptSecretFromBlob, deleteAssetFromGraph, deleteAssetFromPool, deleteCredential, deleteGlobalSample, deleteGraphPackage, deleteProject, deleteProjectSample, deleteRoute, deleteWorkspace, deleteWorkspaceFile, deleteWorkspaceFolder, deleteWorkspaceGraph, encryptSecretToBlob, ensureAssetPoolDirectories, ensureGlobalSamples, ensureGraphAssetDirectories, ensureProjectAssets, ensureProjectsRoot, ensureWorkspaceStructure, exportEncryptedCredentials, fetchCloudflareData, fetchVercelData, findUserWorkspace, findWorkspaceRecord, formatRelativeCreated, getAllRoutes, getAssetPoolLocationPath, getAssetPoolPublicUrl, getB2BucketId, getConnectedDeploymentNode, getConnectedWeightModifiers, getCredential, getDefaultWorkingWorkspaceDir, getExecutions, getGatewayConfig, getGraphPackageById, getPrimarySrklDeploymentUrl as getPrimarySrklCoreDeploymentUrl, getProjectById, getPublicRouteByPath, getPublicRoutes, getSrklAccounts as getSrklCoreAccounts, getSrklStatus, getUnifiedDbUrl, getUsers, getWeightModifierScore, getWorkingWorkspaceConfig, getWorkingWorkspaceDir, getWorkspaceFolderKey, getWorkspaceFolderPrefix, getWorkspaceGraph, getWorkspaceStorageDetails, getWorkspaces, importEncryptedCredentials, importGraphDependency, initGlobalSamplesDirectory, isB2Workspace, listAllGraphPackages, listAllProjects, listBackblazeBuckets, listCredentials, listGlobalSamples, listProjectSamples, listWorkspaceFiles, listWorkspaceGraphs, loadCredentialManifest, loadWorkspaceData, loginUser, matchGatewayIngress, matchGatewayIngressAsync, pauseCloudflarePagesProject, pauseVercelProject, queryUnifiedDb, readWorkspaceFile, recordExecution, removeGraphDependency, renameAppInWorkspaceData, resolveDynamicRouteFromDb, resolveSystemDatabaseUrl, resolveWorkspaceConnection, resolveWorkspaceDir, resumeCloudflarePagesProject, resumeVercelProject, saveAssetToGraph, saveAssetToPool, saveCredentialManifest, saveGlobalSample, saveGraphPackage, saveProject, saveProjectSample, saveWorkspaceData, saveWorkspaceGraph, scanAssetPool, scanGraphAssets, seedDefaultAssets, seedStarterGraphAssets, serverPublicRoutes, setServerPublicRoutes, setWorkingWorkspaceConfig, srklListBackblazeBuckets as srklCoreListBackblazeBuckets, syncWorkspace, syncWorkspaceCreateToBucket, syncWorkspaceDataToBucket, syncWorkspaceDeleteToBucket, tryResolveSystemDatabaseUrl, updateCredential, updateWorkspace, upsertRoute, validateServiceDefinition, writeWorkspaceFile };

package/packages/backend/dist/index.js

@@ -1,3 +1,17 @@
+import {
+  CompositeBackend,
+  EndpointGenerator,
+  LOCAL_STORAGE_GRAPHS_PREFIX,
+  NodeGraphPersistenceService,
+  createBackend,
+  createCompositeService,
+  createLocalService,
+  createRemoteService,
+  exportGraphAsJsonFile,
+  nodeGraphPersistence,
+  parseGraphJsonFile,
+  validateGraphDocument
+} from "./chunk-RBF2OGMC.js";
 import {
   CANONICAL_SRKL_URL,
   SrklClient,
@@ -17,19 +31,8 @@ import {
   useSrklServices
 } from "./chunk-3IUA66RS.js";
 import {
-  CompositeBackend,
-  EndpointGenerator,
-  LOCAL_STORAGE_GRAPHS_PREFIX,
-  NodeGraphPersistenceService,
-  createBackend,
-  createCompositeService,
-  createLocalService,
-  createRemoteService,
-  exportGraphAsJsonFile,
-  nodeGraphPersistence,
-  parseGraphJsonFile,
-  validateGraphDocument
-} from "./chunk-RBF2OGMC.js";
+  S3Adapter
+} from "./chunk-RBQ4CW3T.js";
 import {
   RemoteWorkspaceService,
   SyncEngine,
@@ -46,9 +49,6 @@ import {
   syncWorkspace,
   workingWorkspaceService
 } from "./chunk-BTMIK44G.js";
-import {
-  S3Adapter
-} from "./chunk-RBQ4CW3T.js";
 import {
   AuthServiceDefinition,
   AuthServiceFacade,
@@ -82,15 +82,35 @@ import {
   krnlWorkspaceGraphServiceFacade,
   krnlWorkspaceServiceDefinition,
   krnlWorkspaceServiceFacade
-} from "./chunk-BPFZCDS4.js";
+} from "./chunk-UMEO6XS4.js";
+import {
+  workspaceGraphService
+} from "./chunk-VKSGYMAH.js";
 import {
   getPrimarySrklDeploymentUrl,
   getSrklAccounts,
   srklListBackblazeBuckets
 } from "./chunk-XHADDA75.js";
 import {
-  workspaceGraphService
-} from "./chunk-5RXXC6GE.js";
+  BackblazeB2Adapter,
+  LocalFSAdapter,
+  StorageAdapterFactory,
+  SupabaseStorageAdapter,
+  ensureS3DirectoryMarker,
+  isSecretMasked,
+  normalizeBackblazeCredentials,
+  permanentDeleteS3Folder,
+  permanentDeleteS3Object,
+  renameS3Folder,
+  resolveBackblazeEndpoint
+} from "./chunk-SHZAQTIT.js";
+import {
+  authorizeB2,
+  b2DownloadFile,
+  b2ListBuckets,
+  b2ListFileNames,
+  b2UploadFile
+} from "./chunk-4QEMALXF.js";
 import {
   formatCanonicalWorkspaceFolderName,
   sanitizeWorkspaceName
@@ -125,26 +145,6 @@ import {
   getUnifiedDbUrl,
   queryUnifiedDb
 } from "./chunk-VAFCR2MS.js";
-import {
-  authorizeB2,
-  b2DownloadFile,
-  b2ListBuckets,
-  b2ListFileNames,
-  b2UploadFile
-} from "./chunk-4QEMALXF.js";
-import {
-  BackblazeB2Adapter,
-  LocalFSAdapter,
-  StorageAdapterFactory,
-  SupabaseStorageAdapter,
-  ensureS3DirectoryMarker,
-  isSecretMasked,
-  normalizeBackblazeCredentials,
-  permanentDeleteS3Folder,
-  permanentDeleteS3Object,
-  renameS3Folder,
-  resolveBackblazeEndpoint
-} from "./chunk-SHZAQTIT.js";
 import {
   BaseStorageAdapter,
   GoogleDriveAdapter,
@@ -163,7 +163,7 @@ import {
   BaseAccountProvider,
   LocalAccountProvider,
   PasswordHasher
-} from "./chunk-HT2SEDHD.js";
+} from "./chunk-W6JNJD3Q.js";
 import {
   CanonicalAuthClient,
   RateLimiter,
@@ -171,7 +171,7 @@ import {
   createCanonicalAuthClient,
   loginSystemUser,
   resolveUserFromToken
-} from "./chunk-M4GSR46Y.js";
+} from "./chunk-WTBAG4AV.js";
 import {
   BackendProvider,
   useBackend,
@@ -2058,6 +2058,8 @@ async function fetchCloudflareData(payload, rawUserId, env) {
         id: p.name || p.id,
         name: p.name,
         type: "PAGES_PROJECT",
+        providerProjectId: p.id,
+        providerDeploymentId: p.latest_deployment?.id,
         status: p.latest_deployment?.status || "READY",
         framework: "Cloudflare Pages",
         domain: pDomain,
@@ -2192,6 +2194,7 @@ function buildProjectObservability(projects, deployments, user) {
       fastDataTransferFormatted: "100 MB",
       middlewareInvocations: 10,
       middlewareInvocationsFormatted: "10",
+      latestDeploymentId: latestDep?.id,
       latestDeploymentUrl: `https://${cleanDeploymentUrl}`,
       latestDeploymentStatus: displayStatus,
       latestDeploymentCreatedAt: new Date(createdAtTime).toISOString(),
@@ -2209,7 +2212,8 @@ function buildProjectsList(observability) {
     url: po.latestDeploymentUrl,
     domain: po.domains && po.domains[0] || `${po.projectName}.vercel.app`,
     domains: po.domains || [`${po.projectName}.vercel.app`],
-    updatedAt: po.latestDeploymentCreatedAt
+    updatedAt: po.latestDeploymentCreatedAt,
+    deploymentId: po.latestDeploymentId
   }));
 }
 
@@ -2378,6 +2382,142 @@ async function fetchVercelData(payload, rawUserId, env) {
   }
 }
 
+// src/core/deploymentControlCore.ts
+function firstString(...values) {
+  return values.find((value) => typeof value === "string" && value.trim().length > 0)?.trim() || "";
+}
+async function resolveVercelCredentials(payload, userId, env) {
+  const credentials = payload.credentials || {};
+  let token = firstString(payload.token, payload.apiToken, payload.accessToken, credentials.token, credentials.apiToken, credentials.accessToken);
+  let teamId = firstString(payload.teamId, credentials.teamId);
+  if ((!token || !teamId) && userId && (payload.accountId || credentials.accountId)) {
+    const accountId = firstString(payload.accountId, credentials.accountId);
+    const srkl = await getSrklAccounts2(userId, "vercel", env);
+    const account = srkl.accounts?.find((item) => item.id === accountId);
+    const accountCredentials = account?.credentials || account?.metadata?.credentials || {};
+    token ||= firstString(accountCredentials.token, accountCredentials.apiToken, accountCredentials.accessToken);
+    teamId ||= firstString(accountCredentials.teamId);
+  }
+  if (!token) throw new Error("Vercel API token is missing or not configured for this account.");
+  return { token, teamId };
+}
+async function resolveCloudflareCredentials(payload, userId, env) {
+  const credentials = payload.credentials || {};
+  let token = firstString(payload.token, payload.apiToken, payload.accessToken, credentials.token, credentials.apiToken, credentials.accessToken);
+  let accountId = firstString(payload.accountId, payload.cfAccountId, payload.accountTag, credentials.accountId, credentials.cfAccountId, credentials.accountTag);
+  let authKey = firstString(payload.authKey, payload.globalApiKey, credentials.authKey, credentials.globalApiKey);
+  let authEmail = firstString(payload.authEmail, payload.email, credentials.authEmail, credentials.email);
+  if (!token && !authKey || !accountId) {
+    const requestedAccountId = firstString(payload.accountId, credentials.accountId);
+    if (userId && requestedAccountId) {
+      const srkl = await getSrklAccounts2(userId, "cloudflare", env);
+      const account = srkl.accounts?.find((item) => item.id === requestedAccountId);
+      const accountCredentials = account?.credentials || account?.metadata?.credentials || {};
+      token ||= firstString(accountCredentials.token, accountCredentials.apiToken, accountCredentials.accessToken);
+      accountId ||= firstString(accountCredentials.accountId, accountCredentials.cfAccountId, accountCredentials.accountTag);
+      authKey ||= firstString(accountCredentials.authKey, accountCredentials.globalApiKey);
+      authEmail ||= firstString(accountCredentials.authEmail, accountCredentials.email);
+    }
+  }
+  if (!token && !authKey) throw new Error("Cloudflare API Token or Global API Key required.");
+  if (!accountId) throw new Error("Cloudflare Account ID is required.");
+  return { token, accountId, authKey, authEmail };
+}
+function cloudflareHeaders(token, authKey, authEmail) {
+  const headers = { "Content-Type": "application/json", "User-Agent": "Kloks-DeploymentControl/1.0" };
+  if (token) headers.Authorization = `Bearer ${token}`;
+  else {
+    headers["X-Auth-Key"] = authKey;
+    headers["X-Auth-Email"] = authEmail;
+  }
+  return headers;
+}
+async function assertOk(response, provider) {
+  if (response.ok) return;
+  const body = await response.json().catch(() => ({}));
+  const message = body?.error?.message || body?.errors?.[0]?.message || body?.message || response.statusText;
+  throw new Error(`${provider} API error (${response.status}): ${message}`);
+}
+async function pauseVercelProject(projectId, payload = {}, userId, env) {
+  if (!projectId?.trim()) throw new Error("Vercel project ID is required.");
+  const { token, teamId } = await resolveVercelCredentials(payload, userId, env);
+  const query = teamId ? `?teamId=${encodeURIComponent(teamId)}` : "";
+  const response = await fetch(`https://api.vercel.com/v1/projects/${encodeURIComponent(projectId)}/pause${query}`, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" }
+  });
+  await assertOk(response, "Vercel");
+  return { success: true, provider: "VERCEL", projectId, controlState: "PAUSED" };
+}
+async function resumeVercelProject(projectId, payload = {}, userId, env) {
+  if (!projectId?.trim()) throw new Error("Vercel project ID is required.");
+  const { token, teamId } = await resolveVercelCredentials(payload, userId, env);
+  const query = teamId ? `?teamId=${encodeURIComponent(teamId)}` : "";
+  const response = await fetch(`https://api.vercel.com/v1/projects/${encodeURIComponent(projectId)}/unpause${query}`, {
+    method: "POST",
+    headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" }
+  });
+  await assertOk(response, "Vercel");
+  return { success: true, provider: "VERCEL", projectId, controlState: "ACTIVE" };
+}
+async function pauseCloudflarePagesProject(projectName, payload = {}, userId, env) {
+  if (!projectName?.trim()) throw new Error("Cloudflare Pages project name is required.");
+  const { token, accountId, authKey, authEmail } = await resolveCloudflareCredentials(payload, userId, env);
+  const base = `https://api.cloudflare.com/client/v4/accounts/${encodeURIComponent(accountId)}/pages/projects/${encodeURIComponent(projectName)}`;
+  const currentResponse = await fetch(base, { headers: cloudflareHeaders(token, authKey, authEmail) });
+  await assertOk(currentResponse, "Cloudflare");
+  const current = await currentResponse.json();
+  const config = current?.result?.source?.config;
+  if (!config) throw new Error("Cloudflare Pages project has no source deployment configuration to pause.");
+  const pauseState = {
+    productionDeploymentsEnabled: config.production_deployments_enabled !== false,
+    previewDeploymentSetting: config.preview_deployment_setting || "all"
+  };
+  const updateResponse = await fetch(base, {
+    method: "PATCH",
+    headers: cloudflareHeaders(token, authKey, authEmail),
+    body: JSON.stringify({
+      source: {
+        type: current?.result?.source?.type,
+        config: {
+          ...config,
+          production_deployments_enabled: false,
+          preview_deployment_setting: "none"
+        }
+      }
+    })
+  });
+  await assertOk(updateResponse, "Cloudflare");
+  return { success: true, provider: "CLOUDFLARE", projectId: projectName, controlState: "PAUSED", pauseState };
+}
+async function resumeCloudflarePagesProject(projectName, pauseState, payload = {}, userId, env) {
+  if (!projectName?.trim()) throw new Error("Cloudflare Pages project name is required.");
+  if (!pauseState) throw new Error("Cloudflare Pages pause state is required to resume safely.");
+  const { token, accountId, authKey, authEmail } = await resolveCloudflareCredentials(payload, userId, env);
+  const base = `https://api.cloudflare.com/client/v4/accounts/${encodeURIComponent(accountId)}/pages/projects/${encodeURIComponent(projectName)}`;
+  const currentResponse = await fetch(base, { headers: cloudflareHeaders(token, authKey, authEmail) });
+  await assertOk(currentResponse, "Cloudflare");
+  const current = await currentResponse.json();
+  const config = current?.result?.source?.config;
+  if (!config) throw new Error("Cloudflare Pages project has no source deployment configuration to resume.");
+  const updateResponse = await fetch(base, {
+    method: "PATCH",
+    headers: cloudflareHeaders(token, authKey, authEmail),
+    body: JSON.stringify({
+      source: {
+        type: current?.result?.source?.type,
+        config: {
+          ...config,
+          production_deployments_enabled: pauseState.productionDeploymentsEnabled,
+          preview_deployment_setting: pauseState.previewDeploymentSetting
+        }
+      }
+    })
+  });
+  await assertOk(updateResponse, "Cloudflare");
+  return { success: true, provider: "CLOUDFLARE", projectId: projectName, controlState: "ACTIVE" };
+}
+
 // src/server/wavHelper.ts
 function createWavBuffer(sampleRate, numChannels, samples) {
   const numSamples = samples[0].length;
@@ -4430,6 +4570,8 @@ export {
   nodeGraphPersistence,
   normalizeBackblazeCredentials,
   parseGraphJsonFile,
+  pauseCloudflarePagesProject,
+  pauseVercelProject,
   permanentDeleteS3Folder,
   permanentDeleteS3Object,
   queryUnifiedDb,
@@ -4448,6 +4590,8 @@ export {
   resolveUserFromToken,
   resolveWorkspaceConnection,
   resolveWorkspaceDir,
+  resumeCloudflarePagesProject,
+  resumeVercelProject,
   sanitizeWorkspaceName,
   saveAssetToGraph,
   saveAssetToPool,

package/packages/backend/dist/krnl-services.js

@@ -31,16 +31,16 @@ import {
   krnlWorkspaceGraphServiceFacade,
   krnlWorkspaceServiceDefinition,
   krnlWorkspaceServiceFacade
-} from "./chunk-BPFZCDS4.js";
+} from "./chunk-UMEO6XS4.js";
+import "./chunk-VKSGYMAH.js";
 import "./chunk-XHADDA75.js";
-import "./chunk-5RXXC6GE.js";
+import "./chunk-SHZAQTIT.js";
+import "./chunk-4QEMALXF.js";
 import "./chunk-FZKBTF34.js";
 import "./chunk-6K75XXFD.js";
 import "./chunk-VAFCR2MS.js";
-import "./chunk-4QEMALXF.js";
-import "./chunk-SHZAQTIT.js";
 import "./chunk-KKRWZDMN.js";
-import "./chunk-M4GSR46Y.js";
+import "./chunk-WTBAG4AV.js";
 import "./chunk-TY32TUNI.js";
 export {
   AuthServiceDefinition,

package/packages/backend/dist/services/index.js

@@ -14,10 +14,10 @@ import {
 } from "../chunk-RBF2OGMC.js";
 import {
   workspaceGraphService
-} from "../chunk-5RXXC6GE.js";
+} from "../chunk-VKSGYMAH.js";
+import "../chunk-SHZAQTIT.js";
 import "../chunk-6K75XXFD.js";
 import "../chunk-VAFCR2MS.js";
-import "../chunk-SHZAQTIT.js";
 import "../chunk-KKRWZDMN.js";
 import "../chunk-TY32TUNI.js";
 export {

package/packages/backend/dist/srkl/index.js

@@ -16,8 +16,8 @@ import {
   getSrklAccounts,
   srklListBackblazeBuckets
 } from "../chunk-XHADDA75.js";
-import "../chunk-VAFCR2MS.js";
 import "../chunk-4QEMALXF.js";
+import "../chunk-VAFCR2MS.js";
 export {
   CANONICAL_SRKL_URL,
   SrklClient,

package/packages/backend/dist/storage/index.js

@@ -1,13 +1,6 @@
 import {
   S3Adapter
 } from "../chunk-RBQ4CW3T.js";
-import {
-  authorizeB2,
-  b2DownloadFile,
-  b2ListBuckets,
-  b2ListFileNames,
-  b2UploadFile
-} from "../chunk-4QEMALXF.js";
 import {
   BackblazeB2Adapter,
   LocalFSAdapter,
@@ -21,6 +14,13 @@ import {
   renameS3Folder,
   resolveBackblazeEndpoint
 } from "../chunk-SHZAQTIT.js";
+import {
+  authorizeB2,
+  b2DownloadFile,
+  b2ListBuckets,
+  b2ListFileNames,
+  b2UploadFile
+} from "../chunk-4QEMALXF.js";
 import {
   BaseStorageAdapter,
   GoogleDriveAdapter,

package/packages/contracts/dist/index.d.ts

@@ -575,6 +575,111 @@ interface ServiceUISchema {
     operationBindings: OperationBinding[];
 }
 
+type MonacoDiagnosticSeverity = 'error' | 'warning' | 'info' | 'hint';
+interface MonacoDiagnostic {
+    message: string;
+    severity: MonacoDiagnosticSeverity;
+    startLineNumber: number;
+    startColumn: number;
+    endLineNumber: number;
+    endColumn: number;
+    code?: string;
+}
+interface MonacoDocument {
+    uri: string;
+    language: string;
+    value: string;
+    version: number;
+    diagnostics: MonacoDiagnostic[];
+}
+interface MonacoEditorOptions {
+    readOnly?: boolean;
+    minimap?: boolean;
+    fontSize?: number;
+    wordWrap?: 'off' | 'on' | 'wordWrapColumn' | 'bounded';
+}
+interface MonacoIdeSession {
+    sessionId: string;
+    document: MonacoDocument;
+    options: MonacoEditorOptions;
+    createdAt: number;
+    updatedAt: number;
+}
+interface MonacoCreateSessionInput {
+    sessionId?: string;
+    uri: string;
+    language: string;
+    value: string;
+    options?: MonacoEditorOptions;
+}
+interface MonacoUpdateDocumentInput {
+    sessionId: string;
+    value: string;
+    language?: string;
+}
+
+type UIAuthoringContext = 'service' | 'general-component' | 'application';
+type UIAuthoringNodeKind = 'page' | 'section' | 'component';
+interface UIAuthoringNode {
+    id: string;
+    kind: UIAuthoringNodeKind;
+    name: string;
+    componentId?: string;
+    assetRef?: AssetRef;
+    parentId?: string;
+    props: Record<string, string | number | boolean>;
+}
+interface UIAuthoringBinding {
+    componentId: string;
+    property: string;
+    target: {
+        kind: 'api-input';
+        apiId: string;
+        field: string;
+        fieldType: string;
+    } | {
+        kind: 'api-output';
+        apiId: string;
+        field: string;
+        fieldType: string;
+    };
+}
+interface UIAuthoringOperation {
+    operationId: string;
+    name: string;
+    description?: string;
+    inputFields?: Array<{
+        name: string;
+        type: string;
+    }>;
+    outputFields?: Array<{
+        name: string;
+        type: string;
+    }>;
+}
+interface UIAuthoringSession {
+    sessionId: string;
+    context: UIAuthoringContext;
+    nodes: UIAuthoringNode[];
+    bindings: UIAuthoringBinding[];
+    operations: UIAuthoringOperation[];
+    metadata: Record<string, string>;
+}
+interface UIAuthoringCreateInput {
+    sessionId?: string;
+    context: UIAuthoringContext;
+    operations?: UIAuthoringOperation[];
+    metadata?: Record<string, string>;
+}
+interface UIAuthoringValidation {
+    valid: boolean;
+    errors: string[];
+    warnings: string[];
+}
+declare const UI_AUTHORING_SCHEMA_VERSION = "1.0.0";
+declare function suggestUIComponent(fieldType: string): string;
+declare function buildServiceUISchema(session: UIAuthoringSession): ServiceUISchema;
+
 declare const KLOKS_CANONICAL_CONTRACT: {
     package: string;
     version: string;
@@ -594,4 +699,4 @@ declare const KLOKS_CANONICAL_CONTRACT: {
     validateCompatibility: (consumerSymbols?: string[]) => CompatibilityCheckResult;
 };
 
-export { type AssetRef, type AudioBusConfig, AudioBusConfigSchema, type AudioHardwareState, AudioHardwareStateSchema, type BackendOperation, BackendOperationSchema, type CompatibilityCheckResult, type ComponentDescriptor, type ContractDiffResult, type ContractSnapshot, ContractSnapshotSchema, type ExportSymbolEntry, type GraphEntityMetadata, GraphEntityMetadataSchema, KLOKS_CANONICAL_CONTRACT, KLOKS_PUBLIC_SURFACE, type MidiCommandType, MidiCommandTypeSchema, type MidiEventPayload, MidiEventPayloadSchema, type NodeDimensions2D, NodeDimensions2DSchema, type NodeHeaderStyle, NodeHeaderStyleSchema, type NodeScreenRect2D, NodeScreenRect2DSchema, type OperationBinding, type PageDescriptor, type PublicContractDefinition, PublicContractDefinitionSchema, QWNSR_REQUIRED_SURFACE, type SectionDescriptor, type ServiceUISchema, type SocketDirection, SocketDirectionSchema, type SocketGeometryConfig, SocketGeometryConfigSchema, type SocketPosition2D, SocketPosition2DSchema, type SocketStyleConfig, SocketStyleConfigSchema, type UIRequirementMode, type WireAnimationConfig, WireAnimationConfigSchema, type WireCurveStyle, WireCurveStyleSchema, type WireEndpoint2D, WireEndpoint2DSchema, type WireVisualConfig, WireVisualConfigSchema, createKloksSnapshot, diffContractSnapshots, validateConsumerSurfaceCompatibility };
+export { type AssetRef, type AudioBusConfig, AudioBusConfigSchema, type AudioHardwareState, AudioHardwareStateSchema, type BackendOperation, BackendOperationSchema, type CompatibilityCheckResult, type ComponentDescriptor, type ContractDiffResult, type ContractSnapshot, ContractSnapshotSchema, type ExportSymbolEntry, type GraphEntityMetadata, GraphEntityMetadataSchema, KLOKS_CANONICAL_CONTRACT, KLOKS_PUBLIC_SURFACE, type MidiCommandType, MidiCommandTypeSchema, type MidiEventPayload, MidiEventPayloadSchema, type MonacoCreateSessionInput, type MonacoDiagnostic, type MonacoDiagnosticSeverity, type MonacoDocument, type MonacoEditorOptions, type MonacoIdeSession, type MonacoUpdateDocumentInput, type NodeDimensions2D, NodeDimensions2DSchema, type NodeHeaderStyle, NodeHeaderStyleSchema, type NodeScreenRect2D, NodeScreenRect2DSchema, type OperationBinding, type PageDescriptor, type PublicContractDefinition, PublicContractDefinitionSchema, QWNSR_REQUIRED_SURFACE, type SectionDescriptor, type ServiceUISchema, type SocketDirection, SocketDirectionSchema, type SocketGeometryConfig, SocketGeometryConfigSchema, type SocketPosition2D, SocketPosition2DSchema, type SocketStyleConfig, SocketStyleConfigSchema, type UIAuthoringBinding, type UIAuthoringContext, type UIAuthoringCreateInput, type UIAuthoringNode, type UIAuthoringNodeKind, type UIAuthoringOperation, type UIAuthoringSession, type UIAuthoringValidation, type UIRequirementMode, UI_AUTHORING_SCHEMA_VERSION, type WireAnimationConfig, WireAnimationConfigSchema, type WireCurveStyle, WireCurveStyleSchema, type WireEndpoint2D, WireEndpoint2DSchema, type WireVisualConfig, WireVisualConfigSchema, buildServiceUISchema, createKloksSnapshot, diffContractSnapshots, suggestUIComponent, validateConsumerSurfaceCompatibility };

package/packages/contracts/dist/index.js

@@ -381,6 +381,64 @@ function diffContractSnapshots(previous, current) {
   };
 }
 
+// src/uiAuthoringSchema.ts
+var UI_AUTHORING_SCHEMA_VERSION = "1.0.0";
+function suggestUIComponent(fieldType) {
+  const normalized = fieldType.toLowerCase();
+  if (normalized === "email") return "TextInput.email";
+  if (normalized === "password") return "TextInput.password";
+  if (normalized === "boolean" || normalized === "bool") return "ToggleInput";
+  if (normalized === "number" || normalized === "integer" || normalized === "float") return "NumberInput";
+  if (normalized.includes("date")) return "DateInput";
+  return "TextInput";
+}
+function buildServiceUISchema(session) {
+  if (session.context !== "service") throw new Error("Service UI schema generation requires service context.");
+  const pages = session.nodes.filter((node) => node.kind === "page");
+  const sections = session.nodes.filter((node) => node.kind === "section");
+  const components = session.nodes.filter((node) => node.kind === "component");
+  const assetRefs = components.map((node) => node.assetRef).filter(Boolean);
+  return {
+    schemaId: `kloks.authored-ui.${session.sessionId}`,
+    schemaVersion: UI_AUTHORING_SCHEMA_VERSION,
+    serviceId: session.metadata.serviceId || "unknown-service",
+    requirementMode: "optional",
+    pages: pages.map((page) => ({
+      name: page.name,
+      sections: sections.filter((section) => section.parentId === page.id).map((section) => ({
+        name: section.name,
+        assetRef: section.assetRef,
+        components: components.filter((component) => component.parentId === section.id).map((component) => ({
+          name: component.name,
+          assetRef: component.assetRef,
+          description: component.props.description
+        })),
+        description: section.props.description
+      })),
+      description: page.props.description
+    })),
+    sections: sections.map((section) => ({
+      name: section.name,
+      assetRef: section.assetRef,
+      components: components.filter((component) => component.parentId === section.id).map((component) => ({
+        name: component.name,
+        assetRef: component.assetRef
+      })),
+      description: section.props.description
+    })),
+    components: components.map((component) => ({
+      name: component.name,
+      assetRef: component.assetRef,
+      description: component.props.description
+    })),
+    assetRefs,
+    operationBindings: session.bindings.map((binding) => ({
+      operationId: binding.target.apiId,
+      uiPath: binding.componentId
+    }))
+  };
+}
+
 // src/index.ts
 var KLOKS_CANONICAL_CONTRACT = {
   package: "@ultrst-armada/kloks",
@@ -407,11 +465,14 @@ export {
   SocketGeometryConfigSchema,
   SocketPosition2DSchema,
   SocketStyleConfigSchema,
+  UI_AUTHORING_SCHEMA_VERSION,
   WireAnimationConfigSchema,
   WireCurveStyleSchema,
   WireEndpoint2DSchema,
   WireVisualConfigSchema,
+  buildServiceUISchema,
   createKloksSnapshot,
   diffContractSnapshots,
+  suggestUIComponent,
   validateConsumerSurfaceCompatibility
 };

package/packages/services/dist/index.d.ts

@@ -3,7 +3,7 @@ import { ServiceDefinition, IService, EndpointDescriptor, ProtocolAdapter } from
 import { AdminDatabaseClusterConfig, DatabaseConnectionEntry, UserStorageConnection, AuthState, UserAccount, UserRole, UserWorkspaceRecord } from '@ultrst-armada/kloks/state-graph';
 export { AuthState, UserAccount, UserRole, UserSession, UserStorageConnection, UserWorkspaceRecord } from '@ultrst-armada/kloks/state-graph';
 import * as _kloks_contracts from '@ultrst-armada/kloks/contracts';
-import { ServiceUISchema } from '@ultrst-armada/kloks/contracts';
+import { ServiceUISchema, MonacoIdeSession, UIAuthoringSession } from '@ultrst-armada/kloks/contracts';
 
 interface SystemEnvironmentStatus {
     databaseUrlConfigured: boolean;
@@ -276,6 +276,40 @@ declare const StorageServiceUISchema: ServiceUISchema;
 
 declare const SystemDbServiceUISchema: ServiceUISchema;
 
+interface MonacoState extends Record<string, unknown> {
+    sessions: Record<string, MonacoIdeSession>;
+}
+declare const MonacoIdeServiceDefinition: ServiceDefinition<MonacoState>;
+declare function createMonacoIdeService(): IService<MonacoState>;
+declare const MonacoIdeServiceFacade: {
+    id: string;
+    name: string;
+    version: string;
+    runtime: "client";
+    deployment: "local";
+    definition: ServiceDefinition<MonacoState, Record<string, unknown>>;
+    service: IService<MonacoState, Record<string, unknown>>;
+    createInstance: typeof createMonacoIdeService;
+    execute: <TIn = unknown, TOut = unknown>(operation: string, input?: TIn) => Promise<TOut>;
+};
+
+interface UIAuthoringState extends Record<string, unknown> {
+    sessions: Record<string, UIAuthoringSession>;
+}
+declare const UIAuthoringServiceDefinition: ServiceDefinition<UIAuthoringState>;
+declare function createUIAuthoringService(): IService<UIAuthoringState>;
+declare const UIAuthoringServiceFacade: {
+    id: string;
+    name: string;
+    version: string;
+    runtime: "client";
+    deployment: "local";
+    definition: ServiceDefinition<UIAuthoringState, Record<string, unknown>>;
+    service: IService<UIAuthoringState, Record<string, unknown>>;
+    createInstance: typeof createUIAuthoringService;
+    execute: <TIn = unknown, TOut = unknown>(operation: string, input?: TIn) => Promise<TOut>;
+};
+
 declare const AuthClientServiceDefinition: ServiceDefinition;
 declare const AuthClientServiceFacade: {
     id: string;
@@ -417,4 +451,4 @@ declare const krnlServiceDDefinition: ServiceDefinition<Record<string, unknown>,
 declare const krnlServiceDFacade: ServiceFacade<Record<string, unknown>, Record<string, unknown>>;
 declare const krnlExposeServiceD: typeof exposeServiceD;
 
-export { AuthClientServiceDefinition, AuthClientServiceFacade, type AuthListener, AuthService, AuthServiceUISchema, CLEAN_DATABASE_CLUSTER, type CounterState, DEFAULT_CONNECTIONS, type IAuthStore, type MathInput, type ProtocolExposureHandle, STORAGE_KEY_CONNECTIONS, ServiceADefinition, ServiceAFacade, ServiceBDefinition, ServiceBFacade, ServiceCDefinition, ServiceCFacade, ServiceDDefinition, ServiceDFacade, type ServiceFacade, StorageClientServiceDefinition, StorageClientServiceFacade, StorageService, StorageServiceUISchema, SystemDbClientServiceDefinition, SystemDbClientServiceFacade, SystemDbService, SystemDbServiceUISchema, type SystemEnvironmentStatus, type SystemTelemetry, type TelemetryEvents, authService, clearSession, createServiceB, createServiceC, createWorkspace, deleteWorkspace, exposeServiceD, fetchWorkspaces, krnlAuthClientServiceDefinition, krnlAuthClientServiceFacade, krnlCreateServiceB, krnlCreateServiceC, krnlExposeServiceD, krnlServiceADefinition, krnlServiceAFacade, krnlServiceBDefinition, krnlServiceBFacade, krnlServiceCDefinition, krnlServiceCFacade, krnlServiceDDefinition, krnlServiceDFacade, krnlStorageClientServiceDefinition, krnlStorageClientServiceFacade, krnlSystemDbClientServiceDefinition, krnlSystemDbClientServiceFacade, loadDatabase, loginAdmin, loginUser, persistDatabase, register, restoreSession, setActiveWorkspace, setSession, storageService, systemDbService, updateWorkspace, verifyPassword };
+export { AuthClientServiceDefinition, AuthClientServiceFacade, type AuthListener, AuthService, AuthServiceUISchema, CLEAN_DATABASE_CLUSTER, type CounterState, DEFAULT_CONNECTIONS, type IAuthStore, type MathInput, MonacoIdeServiceDefinition, MonacoIdeServiceFacade, type ProtocolExposureHandle, STORAGE_KEY_CONNECTIONS, ServiceADefinition, ServiceAFacade, ServiceBDefinition, ServiceBFacade, ServiceCDefinition, ServiceCFacade, ServiceDDefinition, ServiceDFacade, type ServiceFacade, StorageClientServiceDefinition, StorageClientServiceFacade, StorageService, StorageServiceUISchema, SystemDbClientServiceDefinition, SystemDbClientServiceFacade, SystemDbService, SystemDbServiceUISchema, type SystemEnvironmentStatus, type SystemTelemetry, type TelemetryEvents, UIAuthoringServiceDefinition, UIAuthoringServiceFacade, authService, clearSession, createMonacoIdeService, createServiceB, createServiceC, createUIAuthoringService, createWorkspace, deleteWorkspace, exposeServiceD, fetchWorkspaces, krnlAuthClientServiceDefinition, krnlAuthClientServiceFacade, krnlCreateServiceB, krnlCreateServiceC, krnlExposeServiceD, krnlServiceADefinition, krnlServiceAFacade, krnlServiceBDefinition, krnlServiceBFacade, krnlServiceCDefinition, krnlServiceCFacade, krnlServiceDDefinition, krnlServiceDFacade, krnlStorageClientServiceDefinition, krnlStorageClientServiceFacade, krnlSystemDbClientServiceDefinition, krnlSystemDbClientServiceFacade, loadDatabase, loginAdmin, loginUser, persistDatabase, register, restoreSession, setActiveWorkspace, setSession, storageService, systemDbService, updateWorkspace, verifyPassword };

package/packages/services/dist/index.js

@@ -1651,6 +1651,251 @@ var StorageService = class {
 };
 var storageService = new StorageService();
 
+// src/client-services/monacoIdeService.ts
+var activeMonacoService;
+var MonacoIdeServiceDefinition = createServiceDefinition({
+  id: "kloks.service.monacoIde",
+  name: "MonacoIdeService",
+  version: "1.0.0",
+  state: { initial: { sessions: {} } },
+  operations: {
+    createSession: {
+      id: "MonacoIdeService.createSession",
+      name: "createSession",
+      handler: async (input, ctx) => {
+        const sessionId = input.sessionId || `monaco-${Date.now().toString(36)}`;
+        const now = Date.now();
+        const session = {
+          sessionId,
+          document: { uri: input.uri, language: input.language, value: input.value, version: 1, diagnostics: [] },
+          options: input.options || {},
+          createdAt: now,
+          updatedAt: now
+        };
+        activeMonacoService.setState({ sessions: { ...activeMonacoService.getState().sessions, [sessionId]: session } });
+        return session;
+      }
+    },
+    updateDocument: {
+      id: "MonacoIdeService.updateDocument",
+      name: "updateDocument",
+      handler: async (input, ctx) => {
+        const current = activeMonacoService.getState().sessions[input.sessionId];
+        if (!current) throw new Error(`Unknown Monaco session: ${input.sessionId}`);
+        const document = {
+          ...current.document,
+          value: input.value,
+          language: input.language || current.document.language,
+          version: current.document.version + 1
+        };
+        const session = { ...current, document, updatedAt: Date.now() };
+        activeMonacoService.setState({ sessions: { ...activeMonacoService.getState().sessions, [session.sessionId]: session } });
+        return session;
+      }
+    },
+    setDiagnostics: {
+      id: "MonacoIdeService.setDiagnostics",
+      name: "setDiagnostics",
+      handler: async (input, ctx) => {
+        const current = activeMonacoService.getState().sessions[input.sessionId];
+        if (!current) throw new Error(`Unknown Monaco session: ${input.sessionId}`);
+        const session = {
+          ...current,
+          document: { ...current.document, diagnostics: input.diagnostics },
+          updatedAt: Date.now()
+        };
+        activeMonacoService.setState({ sessions: { ...activeMonacoService.getState().sessions, [session.sessionId]: session } });
+        return session;
+      }
+    },
+    setOptions: {
+      id: "MonacoIdeService.setOptions",
+      name: "setOptions",
+      handler: async (input, ctx) => {
+        const current = activeMonacoService.getState().sessions[input.sessionId];
+        if (!current) throw new Error(`Unknown Monaco session: ${input.sessionId}`);
+        const session = { ...current, options: { ...current.options, ...input.options }, updatedAt: Date.now() };
+        activeMonacoService.setState({ sessions: { ...activeMonacoService.getState().sessions, [session.sessionId]: session } });
+        return session;
+      }
+    },
+    getSession: {
+      id: "MonacoIdeService.getSession",
+      name: "getSession",
+      handler: async (input, ctx) => activeMonacoService.getState().sessions[input.sessionId] || null
+    },
+    disposeSession: {
+      id: "MonacoIdeService.disposeSession",
+      name: "disposeSession",
+      handler: async (input, ctx) => {
+        const sessions = { ...activeMonacoService.getState().sessions };
+        delete sessions[input.sessionId];
+        activeMonacoService.setState({ sessions });
+        return { disposed: true, sessionId: input.sessionId };
+      }
+    }
+  }
+});
+function createMonacoIdeService() {
+  activeMonacoService = createService(MonacoIdeServiceDefinition);
+  return activeMonacoService;
+}
+var defaultMonacoIdeService = createMonacoIdeService();
+var MonacoIdeServiceFacade = {
+  id: MonacoIdeServiceDefinition.id,
+  name: MonacoIdeServiceDefinition.name,
+  version: MonacoIdeServiceDefinition.version,
+  runtime: "client",
+  deployment: "local",
+  definition: MonacoIdeServiceDefinition,
+  service: defaultMonacoIdeService,
+  createInstance: createMonacoIdeService,
+  execute: async (operation, input) => {
+    await defaultMonacoIdeService.start();
+    return defaultMonacoIdeService.call(operation, input);
+  }
+};
+
+// src/client-services/uiAuthoringService.ts
+import { buildServiceUISchema, suggestUIComponent } from "@ultrst-armada/kloks/contracts";
+var activeUIAuthoringService;
+var UIAuthoringServiceDefinition = createServiceDefinition({
+  id: "kloks.service.uiAuthoring",
+  name: "UIAuthoringService",
+  version: "1.0.0",
+  state: { initial: { sessions: {} } },
+  operations: {
+    createSession: {
+      id: "UIAuthoringService.createSession",
+      name: "createSession",
+      handler: async (input, ctx) => {
+        const sessionId = input.sessionId || `ui-authoring-${Date.now().toString(36)}`;
+        const session = {
+          sessionId,
+          context: input.context,
+          nodes: [],
+          bindings: [],
+          operations: input.operations || [],
+          metadata: input.metadata || {}
+        };
+        activeUIAuthoringService.setState({ sessions: { ...activeUIAuthoringService.getState().sessions, [sessionId]: session } });
+        return session;
+      }
+    },
+    replaceSession: {
+      id: "UIAuthoringService.replaceSession",
+      name: "replaceSession",
+      handler: async (input, ctx) => {
+        if (input.sessionId !== input.session.sessionId) throw new Error("Session id mismatch.");
+        return updateSession(activeUIAuthoringService, input.sessionId, () => input.session);
+      }
+    },
+    addNode: {
+      id: "UIAuthoringService.addNode",
+      name: "addNode",
+      handler: async (input, ctx) => updateSession(activeUIAuthoringService, input.sessionId, (session) => ({
+        ...session,
+        nodes: [...session.nodes.filter((node) => node.id !== input.node.id), input.node]
+      }))
+    },
+    updateNode: {
+      id: "UIAuthoringService.updateNode",
+      name: "updateNode",
+      handler: async (input, ctx) => updateSession(activeUIAuthoringService, input.sessionId, (session) => ({
+        ...session,
+        nodes: session.nodes.map((node) => node.id === input.nodeId ? { ...node, ...input.patch } : node)
+      }))
+    },
+    removeNode: {
+      id: "UIAuthoringService.removeNode",
+      name: "removeNode",
+      handler: async (input, ctx) => updateSession(activeUIAuthoringService, input.sessionId, (session) => ({
+        ...session,
+        nodes: session.nodes.filter((node) => node.id !== input.nodeId && node.parentId !== input.nodeId)
+      }))
+    },
+    setBinding: {
+      id: "UIAuthoringService.setBinding",
+      name: "setBinding",
+      handler: async (input, ctx) => updateSession(activeUIAuthoringService, input.sessionId, (session) => ({
+        ...session,
+        bindings: [...session.bindings.filter((binding) => binding.componentId !== input.binding.componentId || binding.property !== input.binding.property), input.binding]
+      }))
+    },
+    setOperations: {
+      id: "UIAuthoringService.setOperations",
+      name: "setOperations",
+      handler: async (input, ctx) => updateSession(activeUIAuthoringService, input.sessionId, (session) => ({ ...session, operations: input.operations }))
+    },
+    validate: {
+      id: "UIAuthoringService.validate",
+      name: "validate",
+      handler: async (input, ctx) => validateSession(getSession(activeUIAuthoringService, input.sessionId))
+    },
+    serialize: {
+      id: "UIAuthoringService.serialize",
+      name: "serialize",
+      handler: async (input, ctx) => JSON.stringify(getSession(activeUIAuthoringService, input.sessionId), null, 2)
+    },
+    generateServiceUI: {
+      id: "UIAuthoringService.generateServiceUI",
+      name: "generateServiceUI",
+      handler: async (input, ctx) => buildServiceUISchema(getSession(activeUIAuthoringService, input.sessionId))
+    },
+    suggestComponent: {
+      id: "UIAuthoringService.suggestComponent",
+      name: "suggestComponent",
+      handler: async (input) => suggestUIComponent(input.fieldType)
+    },
+    getSession: {
+      id: "UIAuthoringService.getSession",
+      name: "getSession",
+      handler: async (input, ctx) => activeUIAuthoringService.getState().sessions[input.sessionId] || null
+    }
+  }
+});
+function getSession(service, sessionId) {
+  const session = service.getState().sessions[sessionId];
+  if (!session) throw new Error(`Unknown UI authoring session: ${sessionId}`);
+  return session;
+}
+function updateSession(service, sessionId, update) {
+  const session = update(getSession(service, sessionId));
+  service.setState({ sessions: { ...service.getState().sessions, [sessionId]: session } });
+  return session;
+}
+function validateSession(session) {
+  const errors = [];
+  const warnings = [];
+  if (!session.nodes.some((node) => node.kind === "page")) errors.push("At least one page is required.");
+  if (session.nodes.some((node) => node.kind === "component" && !node.assetRef)) errors.push("Every component node requires a FLOKS asset reference.");
+  if (session.context === "service" && !session.metadata.serviceId) errors.push("Service authoring requires metadata.serviceId.");
+  for (const binding of session.bindings) {
+    if (!session.nodes.some((node) => node.id === binding.componentId)) errors.push(`Binding references missing component: ${binding.componentId}`);
+  }
+  if (!session.operations.length) warnings.push("No service operations have been attached to this authoring session.");
+  return { valid: errors.length === 0, errors, warnings };
+}
+function createUIAuthoringService() {
+  activeUIAuthoringService = createService(UIAuthoringServiceDefinition);
+  return activeUIAuthoringService;
+}
+var defaultUIAuthoringService = createUIAuthoringService();
+var UIAuthoringServiceFacade = {
+  id: UIAuthoringServiceDefinition.id,
+  name: UIAuthoringServiceDefinition.name,
+  version: UIAuthoringServiceDefinition.version,
+  runtime: "client",
+  deployment: "local",
+  definition: UIAuthoringServiceDefinition,
+  service: defaultUIAuthoringService,
+  createInstance: createUIAuthoringService,
+  execute: async (operation, input) => {
+    await defaultUIAuthoringService.start();
+    return defaultUIAuthoringService.call(operation, input);
+  }
+};
+
 // src/client-services/index.ts
 var AuthClientServiceDefinition = createServiceDefinition({
   id: "kloks.service.auth",
@@ -1973,6 +2218,8 @@ export {
   AuthServiceUISchema,
   CLEAN_DATABASE_CLUSTER,
   DEFAULT_CONNECTIONS,
+  MonacoIdeServiceDefinition,
+  MonacoIdeServiceFacade,
   STORAGE_KEY_CONNECTIONS,
   ServiceADefinition,
   ServiceAFacade,
@@ -1990,10 +2237,14 @@ export {
   SystemDbClientServiceFacade,
   SystemDbService,
   SystemDbServiceUISchema,
+  UIAuthoringServiceDefinition,
+  UIAuthoringServiceFacade,
   authService,
   clearSession,
+  createMonacoIdeService,
   createServiceB,
   createServiceC,
+  createUIAuthoringService,
   createWorkspace,
   deleteWorkspace,
   exposeServiceD,

package/packages/state-graph/dist/index.js

@@ -7,6 +7,21 @@ import {
   instantiateSubgraph
 } from "./chunk-S22PMERU.js";
 import "./chunk-RHRXPY2U.js";
+import {
+  AttractionEngine,
+  GhostInferenceEngine,
+  GhostLayoutResolver,
+  GhostTracePathBuilder,
+  calculateSocketCoordinates,
+  getBeamPoints,
+  useMagneticTraces
+} from "./chunk-JXDJZSFW.js";
+import {
+  ConnectionRuleStore,
+  HandleTypeRegistry,
+  WireTypeRegistry,
+  initializeDefaultGraphRules
+} from "./chunk-TZOL3RN7.js";
 import {
   LifecycleCycleError,
   LifecycleGraph,
@@ -30,21 +45,6 @@ import {
   CustomViewWindow,
   DEFAULT_GRAPH_SETTINGS
 } from "./chunk-KG6QYS26.js";
-import {
-  AttractionEngine,
-  GhostInferenceEngine,
-  GhostLayoutResolver,
-  GhostTracePathBuilder,
-  calculateSocketCoordinates,
-  getBeamPoints,
-  useMagneticTraces
-} from "./chunk-JXDJZSFW.js";
-import {
-  ConnectionRuleStore,
-  HandleTypeRegistry,
-  WireTypeRegistry,
-  initializeDefaultGraphRules
-} from "./chunk-TZOL3RN7.js";
 import {
   AutoSolidify,
   SpatialEngine,

package/packages/backend/dist/{chunk-5RXXC6GE.js → chunk-VKSGYMAH.js}

@@ -1,9 +1,9 @@
-import {
-  findUserWorkspace
-} from "./chunk-6K75XXFD.js";
 import {
   StorageAdapterFactory
 } from "./chunk-SHZAQTIT.js";
+import {
+  findUserWorkspace
+} from "./chunk-6K75XXFD.js";
 
 // src/services/workspaceGraphService.ts
 function slugify(name) {