@ultrst-armada/kloks 1.8.0 → 1.10.0

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

@@ -575,6 +575,129 @@ 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;
+
+type UIComponentPurpose = 'service-ui' | 'general-purpose' | 'application-specific';
+type UIComponentPromotion = 'always' | 'usually' | 'never';
+interface UIComponentArtifact {
+    artifactId: string;
+    schemaVersion: string;
+    purpose: UIComponentPurpose;
+    promotion: UIComponentPromotion;
+    origin: 'kult' | 'theta' | 'kelt' | 'other';
+    context: UIAuthoringContext;
+    name: string;
+    description: string;
+    rootAsset?: AssetRef;
+    session: UIAuthoringSession;
+}
+declare function getUIComponentPurpose(context: UIAuthoringContext): UIComponentPurpose;
+declare function getUIComponentPromotion(purpose: UIComponentPurpose): UIComponentPromotion;
+declare function buildUIComponentArtifact(session: UIAuthoringSession): UIComponentArtifact;
+
 declare const KLOKS_CANONICAL_CONTRACT: {
     package: string;
     version: string;
@@ -594,4 +717,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 UIComponentArtifact, type UIComponentPromotion, type UIComponentPurpose, type UIRequirementMode, UI_AUTHORING_SCHEMA_VERSION, type WireAnimationConfig, WireAnimationConfigSchema, type WireCurveStyle, WireCurveStyleSchema, type WireEndpoint2D, WireEndpoint2DSchema, type WireVisualConfig, WireVisualConfigSchema, buildServiceUISchema, buildUIComponentArtifact, createKloksSnapshot, diffContractSnapshots, getUIComponentPromotion, getUIComponentPurpose, suggestUIComponent, validateConsumerSurfaceCompatibility };

package/packages/contracts/dist/index.js

@@ -381,6 +381,92 @@ 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/uiAuthoringArtifactSchema.ts
+function getUIComponentPurpose(context) {
+  if (context === "service") return "service-ui";
+  if (context === "general-component") return "general-purpose";
+  return "application-specific";
+}
+function getUIComponentPromotion(purpose) {
+  if (purpose === "service-ui" || purpose === "general-purpose") return "always";
+  return "usually";
+}
+function buildUIComponentArtifact(session) {
+  const purpose = getUIComponentPurpose(session.context);
+  const origin = session.metadata.origin === "kult" || session.metadata.origin === "theta" || session.metadata.origin === "kelt" ? session.metadata.origin : "other";
+  const root = session.nodes.find((node) => node.kind === "component" && !node.parentId)?.assetRef;
+  return {
+    artifactId: "kloks.ui-artifact." + session.sessionId,
+    schemaVersion: "1.0.0",
+    purpose,
+    promotion: getUIComponentPromotion(purpose),
+    origin,
+    context: session.context,
+    name: session.metadata.name || session.sessionId,
+    description: session.metadata.description || "",
+    rootAsset: root,
+    session
+  };
+}
+
 // src/index.ts
 var KLOKS_CANONICAL_CONTRACT = {
   package: "@ultrst-armada/kloks",
@@ -407,11 +493,17 @@ export {
   SocketGeometryConfigSchema,
   SocketPosition2DSchema,
   SocketStyleConfigSchema,
+  UI_AUTHORING_SCHEMA_VERSION,
   WireAnimationConfigSchema,
   WireCurveStyleSchema,
   WireEndpoint2DSchema,
   WireVisualConfigSchema,
+  buildServiceUISchema,
+  buildUIComponentArtifact,
   createKloksSnapshot,
   diffContractSnapshots,
+  getUIComponentPromotion,
+  getUIComponentPurpose,
+  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,265 @@ 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, buildUIComponentArtifact, 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)
+    },
+    generateArtifact: {
+      id: "UIAuthoringService.generateArtifact",
+      name: "generateArtifact",
+      handler: async (input, ctx) => buildUIComponentArtifact(getSession(activeUIAuthoringService, input.sessionId))
+    },
+    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.");
+  const ids = /* @__PURE__ */ new Set();
+  for (const node of session.nodes) {
+    if (ids.has(node.id)) errors.push(`Duplicate authoring node id: ${node.id}`);
+    ids.add(node.id);
+    if (node.parentId && !session.nodes.some((parent) => parent.id === node.parentId)) errors.push(`Missing parent for node: ${node.id}`);
+    if (node.kind === "page" && node.parentId) errors.push(`Page cannot have a parent: ${node.id}`);
+    if (node.kind === "section" && node.parentId && !session.nodes.some((parent) => parent.id === node.parentId && parent.kind === "page")) errors.push(`Section parent must be a page: ${node.id}`);
+    if (node.kind === "component" && node.parentId && !session.nodes.some((parent) => parent.id === node.parentId && parent.kind === "section")) errors.push(`Component parent must be a section: ${node.id}`);
+  }
+  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 +2232,8 @@ export {
   AuthServiceUISchema,
   CLEAN_DATABASE_CLUSTER,
   DEFAULT_CONNECTIONS,
+  MonacoIdeServiceDefinition,
+  MonacoIdeServiceFacade,
   STORAGE_KEY_CONNECTIONS,
   ServiceADefinition,
   ServiceAFacade,
@@ -1990,10 +2251,14 @@ export {
   SystemDbClientServiceFacade,
   SystemDbService,
   SystemDbServiceUISchema,
+  UIAuthoringServiceDefinition,
+  UIAuthoringServiceFacade,
   authService,
   clearSession,
+  createMonacoIdeService,
   createServiceB,
   createServiceC,
+  createUIAuthoringService,
   createWorkspace,
   deleteWorkspace,
   exposeServiceD,

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

@@ -7,29 +7,6 @@ import {
   instantiateSubgraph
 } from "./chunk-S22PMERU.js";
 import "./chunk-RHRXPY2U.js";
-import {
-  LifecycleCycleError,
-  LifecycleGraph,
-  SKIPO_STATE,
-  SkipoStateEngine,
-  useLifecycleScope,
-  useSkipoBind,
-  useSkipoState
-} from "./chunk-EW4ACSZB.js";
-import {
-  CommandApi,
-  GhostStore,
-  GraphStore
-} from "./chunk-4UVGXFEM.js";
-import {
-  BaseGraph,
-  BaseNode,
-  BaseViewWindow,
-  CustomGraph,
-  CustomNode,
-  CustomViewWindow,
-  DEFAULT_GRAPH_SETTINGS
-} from "./chunk-KG6QYS26.js";
 import {
   AttractionEngine,
   GhostInferenceEngine,
@@ -45,6 +22,20 @@ import {
   WireTypeRegistry,
   initializeDefaultGraphRules
 } from "./chunk-TZOL3RN7.js";
+import {
+  CommandApi,
+  GhostStore,
+  GraphStore
+} from "./chunk-4UVGXFEM.js";
+import {
+  BaseGraph,
+  BaseNode,
+  BaseViewWindow,
+  CustomGraph,
+  CustomNode,
+  CustomViewWindow,
+  DEFAULT_GRAPH_SETTINGS
+} from "./chunk-KG6QYS26.js";
 import {
   AutoSolidify,
   SpatialEngine,
@@ -58,6 +49,15 @@ import {
 import {
   CompatibilityMatrix
 } from "./chunk-ISFNY7EZ.js";
+import {
+  LifecycleCycleError,
+  LifecycleGraph,
+  SKIPO_STATE,
+  SkipoStateEngine,
+  useLifecycleScope,
+  useSkipoBind,
+  useSkipoState
+} from "./chunk-EW4ACSZB.js";
 
 // ../../node_modules/.pnpm/@ultrst-armada+krnl@1.0.3/node_modules/@ultrst-armada/krnl/packages/core/dist/index.js
 var ServiceStateStore = class {

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) {