@ultrst-armada/kloks 1.5.1 → 1.6.0

package/.krusbl-release-attestation.json

@@ -1,8 +1,8 @@
 {
   "schema": 1,
   "packageName": "@ultrst-armada/kloks",
-  "version": "1.5.1",
-  "sourceCommit": "df4285ad26bbf5f16acaca63ba43fe4e40740051",
+  "version": "1.6.0",
+  "sourceCommit": "a44775f58baed156dbc5590d9d920e6b582f2eee",
   "releaseWorkflow": "npm Release",
-  "workflowRunId": "39943915592"
+  "workflowRunId": "39983348775"
 }

package/package.json

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

package/packages/backend/dist/{chunk-OVTXAGL6.js → chunk-3HZYAZF4.js}

@@ -169,6 +169,10 @@ var WebContainerRuntime = class {
       release();
     }
   }
+  async spawnCommand(command, args = [], cwd, env) {
+    const container = await this.boot();
+    return container.spawn(command, args, { cwd, env });
+  }
   async teardown() {
     const container = this.container;
     this.container = null;
@@ -239,7 +243,8 @@ var DevelopmentServiceDefinition = createServiceDefinition({
       name: "describeProviders",
       handler: async () => ({
         providers: [
-          { id: "webcontainer", capabilities: ["install", "lint", "test", "build", "validate", "check"] },
+          { id: "webcontainer", capabilities: ["install", "lint", "test", "build", "validate", "check", "process-host"] },
+          { id: "typescript-language-server", capabilities: ["lsp", "diagnostics", "completion", "hover", "definition", "references", "rename", "symbols"] },
           { id: "github-actions", capabilities: ["dispatch", "observe", "rerun", "cancel"] }
         ]
       })
@@ -284,6 +289,219 @@ var DevelopmentServiceFacade = {
   }
 };
 
+// src/development/codeValidationService.ts
+var COMMANDS2 = {
+  syntax: { command: "pnpm", args: ["exec", "tsc", "--noEmit"] },
+  lint: { command: "pnpm", args: ["run", "lint", "--if-present"] },
+  test: { command: "pnpm", args: ["run", "test", "--if-present"] },
+  build: { command: "pnpm", args: ["run", "build", "--if-present"] },
+  krnl: { command: "pnpm", args: ["exec", "krnl", "validate"] },
+  frnl: { command: "pnpm", args: ["exec", "frnl", "validate"] }
+};
+var DEFAULT_LAYERS = ["syntax", "lint", "krnl", "frnl"];
+var commandText = (command, args) => [command, ...args].join(" ");
+var CodeValidationRuntime = class {
+  constructor(runtime4 = new WebContainerRuntime()) {
+    this.runtime = runtime4;
+  }
+  runtime;
+  async validate(input = {}) {
+    if (input.files) await this.runtime.mount(input.files);
+    const diagnostics = [];
+    if (input.install) {
+      const installed = await this.runtime.runCommand("pnpm", ["install", "--no-frozen-lockfile"], input.cwd, input.env);
+      diagnostics.push({ layer: "lint", ok: installed.exitCode === 0, exitCode: installed.exitCode, output: installed.output, command: "pnpm install --no-frozen-lockfile" });
+      if (installed.exitCode !== 0) return { ok: false, diagnostics, failedLayers: ["lint"] };
+    }
+    const layers = input.layers?.length ? input.layers : DEFAULT_LAYERS;
+    for (const layer of layers) {
+      if (layer === "law-l9") {
+        diagnostics.push(await this.validateLawL9(input.cwd, input.maxLines ?? 200));
+        continue;
+      }
+      const spec = COMMANDS2[layer];
+      const result = await this.runtime.runCommand(spec.command, spec.args, input.cwd, input.env);
+      diagnostics.push({ layer, ok: result.exitCode === 0, exitCode: result.exitCode, output: result.output, command: commandText(spec.command, spec.args) });
+      if (result.exitCode !== 0) break;
+    }
+    return { ok: diagnostics.every((item) => item.ok), diagnostics, failedLayers: diagnostics.filter((item) => !item.ok).map((item) => item.layer) };
+  }
+  async validateLawL9(cwd = ".", maxLines = 200) {
+    const script = `python3 -c 'import os,sys; bad=[]; root="src"; [bad.append(os.path.join(r,f)+": "+str(len(open(os.path.join(r,f),encoding="utf-8",errors="ignore").readlines()))+" lines") for r,_,fs in os.walk(root) for f in fs if f.endswith((".ts",".tsx",".js",".jsx")) and not f.endswith(".d.ts") and len(open(os.path.join(r,f),encoding="utf-8",errors="ignore").readlines())>200]; print("\\n".join(bad)); sys.exit(1 if bad else 0)'`;
+    const result = await this.runtime.runCommand("sh", ["-lc", script], cwd);
+    return { layer: "law-l9", ok: result.exitCode === 0, exitCode: result.exitCode, output: result.output, command: script };
+  }
+};
+var runtime2 = new CodeValidationRuntime();
+var CodeValidationServiceDefinition = createServiceDefinition({
+  id: "kloks.backend.codeValidation",
+  name: "CodeValidationService",
+  version: "1.0.0",
+  operations: { validate: { id: "CodeValidationService.validate", name: "validate", handler: async (input) => runtime2.validate(input) } }
+});
+var CodeValidationServiceFacade = {
+  id: CodeValidationServiceDefinition.id,
+  name: CodeValidationServiceDefinition.name,
+  version: CodeValidationServiceDefinition.version,
+  runtime: "client",
+  deployment: "local",
+  definition: CodeValidationServiceDefinition,
+  createInstance: () => createService(CodeValidationServiceDefinition),
+  execute: async (op, input) => {
+    const instance = createService(CodeValidationServiceDefinition);
+    await instance.start();
+    return instance.call(op, input);
+  }
+};
+
+// src/development/codeDiagnosticsService.ts
+var CodeDiagnosticsService = class {
+  constructor(runtime4 = new WebContainerRuntime()) {
+    this.runtime = runtime4;
+  }
+  runtime;
+  async diagnostics(input = {}) {
+    const args = ["exec", "tsc", "--noEmit", "--pretty", "false"];
+    if (input.file) args.push(input.file);
+    const result = await this.runtime.runCommand("pnpm", args, input.cwd);
+    return { ok: result.exitCode === 0, output: result.output, command: ["pnpm", ...args].join(" ") };
+  }
+};
+var codeDiagnosticsService = new CodeDiagnosticsService();
+
+// src/development/typescriptLanguageServerService.ts
+var TYPESCRIPT_LANGUAGE_SERVER_PACKAGE = "typescript-language-server";
+var TYPESCRIPT_LANGUAGE_SERVER_VERSION = "6.0.2";
+var PACKAGE = TYPESCRIPT_LANGUAGE_SERVER_PACKAGE;
+var DEFAULT_VERSION = TYPESCRIPT_LANGUAGE_SERVER_VERSION;
+var TypeScriptLanguageServerRuntime = class {
+  constructor(runtime4 = new WebContainerRuntime()) {
+    this.runtime = runtime4;
+  }
+  runtime;
+  process = null;
+  writer = null;
+  pending = /* @__PURE__ */ new Map();
+  buffer = "";
+  cwd = ".";
+  version = DEFAULT_VERSION;
+  async start(input = {}) {
+    if (this.process) return this.status();
+    this.cwd = input.cwd ?? ".";
+    this.version = input.version ?? DEFAULT_VERSION;
+    if (input.install !== false) {
+      await this.runtime.runCommand("pnpm", ["add", "-D", "typescript@7.0.2", PACKAGE + "@" + this.version], this.cwd);
+    }
+    this.process = await this.runtime.spawnCommand("pnpm", ["exec", PACKAGE, "--stdio"], this.cwd);
+    this.writer = this.process.input.getWriter();
+    void this.readOutput(this.process.output);
+    return this.status();
+  }
+  async request(input) {
+    await this.ensureRunning();
+    const promise = new Promise((resolve, reject) => {
+      this.pending.set(input.id, { resolve, reject });
+    });
+    await this.write(input);
+    return promise;
+  }
+  async notify(input) {
+    await this.ensureRunning();
+    await this.write(input);
+    return { sent: true };
+  }
+  async stop() {
+    const process = this.process;
+    this.process = null;
+    this.writer?.releaseLock();
+    this.writer = null;
+    for (const pending of this.pending.values()) pending.reject(new Error("Language server stopped"));
+    this.pending.clear();
+    if (process) await process.kill();
+    return { stopped: true };
+  }
+  status() {
+    return { running: Boolean(this.process), cwd: this.cwd, package: PACKAGE, version: this.version };
+  }
+  async ensureRunning() {
+    if (!this.process) await this.start({ cwd: this.cwd, install: false, version: this.version });
+  }
+  async write(message) {
+    if (!this.writer) throw new Error("Language server input is unavailable");
+    const body = JSON.stringify({ jsonrpc: "2.0", ...message });
+    const frame = "Content-Length: " + new TextEncoder().encode(body).byteLength + "\r\n\r\n" + body;
+    await this.writer.write(frame);
+  }
+  async readOutput(output) {
+    const reader = output.getReader();
+    try {
+      while (true) {
+        const next = await reader.read();
+        if (next.done) break;
+        this.buffer += next.value;
+        this.consumeFrames();
+      }
+    } catch (error) {
+      for (const pending of this.pending.values()) pending.reject(error instanceof Error ? error : new Error(String(error)));
+      this.pending.clear();
+    } finally {
+      reader.releaseLock();
+      this.process = null;
+      this.writer?.releaseLock();
+      this.writer = null;
+    }
+  }
+  consumeFrames() {
+    while (true) {
+      const separator = this.buffer.indexOf("\r\n\r\n");
+      if (separator < 0) return;
+      const header = this.buffer.slice(0, separator);
+      const match = header.match(/Content-Length:\s*(\d+)/i);
+      if (!match) {
+        this.buffer = this.buffer.slice(separator + 4);
+        continue;
+      }
+      const length = Number(match[1]);
+      const start = separator + 4;
+      if (this.buffer.length - start < length) return;
+      const body = this.buffer.slice(start, start + length);
+      this.buffer = this.buffer.slice(start + length);
+      const response = JSON.parse(body);
+      if (response.id !== void 0 && response.id !== null) {
+        this.pending.get(response.id)?.resolve(response);
+        this.pending.delete(response.id);
+      }
+    }
+  }
+};
+var runtime3 = new TypeScriptLanguageServerRuntime();
+var TypeScriptLanguageServerServiceDefinition = createServiceDefinition({
+  id: "kloks.backend.typescriptLanguageServer",
+  name: "TypeScriptLanguageServerService",
+  version: "1.0.0",
+  operations: {
+    start: { id: "TypeScriptLanguageServerService.start", name: "start", handler: async (input) => runtime3.start(input) },
+    request: { id: "TypeScriptLanguageServerService.request", name: "request", handler: async (input) => runtime3.request(input) },
+    notify: { id: "TypeScriptLanguageServerService.notify", name: "notify", handler: async (input) => runtime3.notify(input) },
+    stop: { id: "TypeScriptLanguageServerService.stop", name: "stop", handler: async () => runtime3.stop() },
+    status: { id: "TypeScriptLanguageServerService.status", name: "status", handler: async () => runtime3.status() }
+  }
+});
+var TypeScriptLanguageServerServiceFacade = {
+  id: TypeScriptLanguageServerServiceDefinition.id,
+  name: TypeScriptLanguageServerServiceDefinition.name,
+  version: TypeScriptLanguageServerServiceDefinition.version,
+  runtime: "client",
+  deployment: "local",
+  definition: TypeScriptLanguageServerServiceDefinition,
+  createInstance: () => createService(TypeScriptLanguageServerServiceDefinition),
+  execute: async (op, input) => {
+    const instance = createService(TypeScriptLanguageServerServiceDefinition);
+    await instance.start();
+    return instance.call(op, input);
+  }
+};
+
 export {
   GitHubActionsClient,
   GitHubActionsServiceDefinition,
@@ -294,5 +512,14 @@ export {
   resolveDevelopmentCommand,
   DevelopmentServiceDefinition,
   DevelopmentRuntime,
-  DevelopmentServiceFacade
+  DevelopmentServiceFacade,
+  CodeValidationRuntime,
+  CodeValidationServiceDefinition,
+  CodeValidationServiceFacade,
+  CodeDiagnosticsService,
+  codeDiagnosticsService,
+  TYPESCRIPT_LANGUAGE_SERVER_PACKAGE,
+  TYPESCRIPT_LANGUAGE_SERVER_VERSION,
+  TypeScriptLanguageServerServiceDefinition,
+  TypeScriptLanguageServerServiceFacade
 };

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

@@ -108,6 +108,7 @@ declare class WebContainerRuntime {
         exitCode: any;
         output: string;
     }>;
+    spawnCommand(command: string, args?: string[], cwd?: string, env?: Record<string, string | number | boolean>): Promise<any>;
     teardown(): Promise<{
         tornDown: boolean;
     }>;
@@ -143,4 +144,105 @@ declare const DevelopmentServiceFacade: {
     execute: <TIn = unknown, TOut = unknown>(op: string, input?: TIn) => Promise<TOut>;
 };
 
-export { type DevelopmentProvider, type DevelopmentRequest, type DevelopmentResult, DevelopmentRuntime, type DevelopmentServiceContract, DevelopmentServiceDefinition, DevelopmentServiceFacade, type DevelopmentTask, GitHubActionsClient, type GitHubActionsConfig, GitHubActionsServiceDefinition, GitHubActionsServiceFacade, type WebContainerCommand, type WebContainerRunCommandInput, WebContainerRuntime, WebContainerServiceDefinition, WebContainerServiceFacade, type WorkflowRun, resolveDevelopmentCommand };
+type ValidationLayer = 'syntax' | 'lint' | 'test' | 'build' | 'krnl' | 'frnl' | 'law-l9';
+interface CodeValidationInput {
+    layers?: ValidationLayer[];
+    cwd?: string;
+    env?: Record<string, string>;
+    maxLines?: number;
+    files?: Record<string, unknown>;
+    install?: boolean;
+}
+interface ValidationDiagnostic {
+    layer: ValidationLayer;
+    ok: boolean;
+    exitCode: number;
+    output: string;
+    command: string;
+}
+interface CodeValidationResult {
+    ok: boolean;
+    diagnostics: ValidationDiagnostic[];
+    failedLayers: ValidationLayer[];
+}
+
+declare class CodeValidationRuntime {
+    private readonly runtime;
+    constructor(runtime?: WebContainerRuntime);
+    validate(input?: CodeValidationInput): Promise<CodeValidationResult>;
+    private validateLawL9;
+}
+declare const CodeValidationServiceDefinition: ServiceDefinition;
+declare const CodeValidationServiceFacade: {
+    id: string;
+    name: string;
+    version: string;
+    runtime: "client";
+    deployment: "local";
+    definition: ServiceDefinition<Record<string, unknown>, Record<string, unknown>>;
+    createInstance: () => _ultrst_armada_krnl.ServiceInstance<Record<string, unknown>, Record<string, unknown>>;
+    execute: <TIn = CodeValidationInput, TOut = CodeValidationResult>(op: string, input?: TIn) => Promise<TOut>;
+};
+
+interface CodeDiagnosticsInput {
+    cwd?: string;
+    file?: string;
+}
+interface CodeDiagnosticsResult {
+    ok: boolean;
+    output: string;
+    command: string;
+}
+declare class CodeDiagnosticsService {
+    private readonly runtime;
+    constructor(runtime?: WebContainerRuntime);
+    diagnostics(input?: CodeDiagnosticsInput): Promise<CodeDiagnosticsResult>;
+}
+declare const codeDiagnosticsService: CodeDiagnosticsService;
+
+interface TypeScriptLanguageServerStartInput {
+    cwd?: string;
+    install?: boolean;
+    version?: string;
+}
+interface TypeScriptLanguageServerRequestInput {
+    id: number | string;
+    method: string;
+    params?: unknown;
+}
+interface TypeScriptLanguageServerNotificationInput {
+    method: string;
+    params?: unknown;
+}
+interface TypeScriptLanguageServerResponse {
+    jsonrpc: '2.0';
+    id?: number | string | null;
+    result?: unknown;
+    error?: {
+        code: number;
+        message: string;
+        data?: unknown;
+    };
+}
+interface TypeScriptLanguageServerStatus {
+    running: boolean;
+    cwd?: string;
+    package: string;
+    version: string;
+}
+
+declare const TYPESCRIPT_LANGUAGE_SERVER_PACKAGE = "typescript-language-server";
+declare const TYPESCRIPT_LANGUAGE_SERVER_VERSION = "6.0.2";
+declare const TypeScriptLanguageServerServiceDefinition: ServiceDefinition;
+declare const TypeScriptLanguageServerServiceFacade: {
+    id: string;
+    name: string;
+    version: string;
+    runtime: "client";
+    deployment: "local";
+    definition: ServiceDefinition<Record<string, unknown>, Record<string, unknown>>;
+    createInstance: () => _ultrst_armada_krnl.ServiceInstance<Record<string, unknown>, Record<string, unknown>>;
+    execute: <TIn = unknown, TOut = unknown>(op: string, input?: TIn) => Promise<TOut>;
+};
+
+export { type CodeDiagnosticsInput, type CodeDiagnosticsResult, CodeDiagnosticsService, type CodeValidationInput, type CodeValidationResult, CodeValidationRuntime, CodeValidationServiceDefinition, CodeValidationServiceFacade, type DevelopmentProvider, type DevelopmentRequest, type DevelopmentResult, DevelopmentRuntime, type DevelopmentServiceContract, DevelopmentServiceDefinition, DevelopmentServiceFacade, type DevelopmentTask, GitHubActionsClient, type GitHubActionsConfig, GitHubActionsServiceDefinition, GitHubActionsServiceFacade, TYPESCRIPT_LANGUAGE_SERVER_PACKAGE, TYPESCRIPT_LANGUAGE_SERVER_VERSION, type TypeScriptLanguageServerNotificationInput, type TypeScriptLanguageServerRequestInput, type TypeScriptLanguageServerResponse, TypeScriptLanguageServerServiceDefinition, TypeScriptLanguageServerServiceFacade, type TypeScriptLanguageServerStartInput, type TypeScriptLanguageServerStatus, type ValidationDiagnostic, type ValidationLayer, type WebContainerCommand, type WebContainerRunCommandInput, WebContainerRuntime, WebContainerServiceDefinition, WebContainerServiceFacade, type WorkflowRun, codeDiagnosticsService, resolveDevelopmentCommand };

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

@@ -1,25 +1,43 @@
 import {
+  CodeDiagnosticsService,
+  CodeValidationRuntime,
+  CodeValidationServiceDefinition,
+  CodeValidationServiceFacade,
   DevelopmentRuntime,
   DevelopmentServiceDefinition,
   DevelopmentServiceFacade,
   GitHubActionsClient,
   GitHubActionsServiceDefinition,
   GitHubActionsServiceFacade,
+  TYPESCRIPT_LANGUAGE_SERVER_PACKAGE,
+  TYPESCRIPT_LANGUAGE_SERVER_VERSION,
+  TypeScriptLanguageServerServiceDefinition,
+  TypeScriptLanguageServerServiceFacade,
   WebContainerRuntime,
   WebContainerServiceDefinition,
   WebContainerServiceFacade,
+  codeDiagnosticsService,
   resolveDevelopmentCommand
-} from "../chunk-OVTXAGL6.js";
+} from "../chunk-3HZYAZF4.js";
 import "../chunk-TY32TUNI.js";
 export {
+  CodeDiagnosticsService,
+  CodeValidationRuntime,
+  CodeValidationServiceDefinition,
+  CodeValidationServiceFacade,
   DevelopmentRuntime,
   DevelopmentServiceDefinition,
   DevelopmentServiceFacade,
   GitHubActionsClient,
   GitHubActionsServiceDefinition,
   GitHubActionsServiceFacade,
+  TYPESCRIPT_LANGUAGE_SERVER_PACKAGE,
+  TYPESCRIPT_LANGUAGE_SERVER_VERSION,
+  TypeScriptLanguageServerServiceDefinition,
+  TypeScriptLanguageServerServiceFacade,
   WebContainerRuntime,
   WebContainerServiceDefinition,
   WebContainerServiceFacade,
+  codeDiagnosticsService,
   resolveDevelopmentCommand
 };

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

@@ -13,7 +13,7 @@ export { AdaptedStorageConnection, AppAccountManifest, AppServiceDeclaration, CA
 export { CompositeBackend, EndpointGenerator, GeneratedEndpointSummary, LOCAL_STORAGE_GRAPHS_PREFIX, LocalService, NodeGraphPersistenceService, NodeGraphValidationResult, RemoteServiceProxy, SaveGraphOptions, UniversalAppEntity, UniversalGraphEdge, UniversalGraphNode, UniversalNodeGraphDocument, UniversalStorageConnection, WorkspaceGraphDocument, WorkspaceGraphSummary, createBackend, createCompositeService, createLocalService, createRemoteService, exportGraphAsJsonFile, nodeGraphPersistence, parseGraphJsonFile, validateGraphDocument, workspaceGraphService } from './services/index.js';
 import { AssetDataType as AssetDataType$1, AssetChannelType as AssetChannelType$1, GraphFolderInfo as GraphFolderInfo$1, GraphAssetItem as GraphAssetItem$1, SpaceNode, NodeConnection, DawProject } from '@ultrst-armada/kloks/state-graph';
 export { AuthServiceDefinition, AuthServiceFacade, ControlPlaneServiceDefinition, ControlPlaneServiceFacade, DatabaseServiceDefinition, DatabaseServiceFacade, GeminiServiceDefinition, GeminiServiceFacade, SrklServiceDefinition, SrklServiceFacade, StorageServiceDefinition, StorageServiceFacade, WorkspaceGraphServiceDefinition, WorkspaceGraphServiceFacade, WorkspaceServiceDefinition, WorkspaceServiceFacade, krnlAuthServiceDefinition, krnlAuthServiceFacade, krnlControlPlaneServiceDefinition, krnlControlPlaneServiceFacade, krnlDatabaseServiceDefinition, krnlDatabaseServiceFacade, krnlGeminiServiceDefinition, krnlGeminiServiceFacade, krnlSrklServiceDefinition, krnlSrklServiceFacade, krnlStorageServiceDefinition, krnlStorageServiceFacade, krnlWorkspaceGraphServiceDefinition, krnlWorkspaceGraphServiceFacade, krnlWorkspaceServiceDefinition, krnlWorkspaceServiceFacade } from './krnl-services.js';
-export { DevelopmentProvider, DevelopmentRequest, DevelopmentResult, DevelopmentRuntime, DevelopmentServiceContract, DevelopmentServiceDefinition, DevelopmentServiceFacade, DevelopmentTask, GitHubActionsClient, GitHubActionsConfig, GitHubActionsServiceDefinition, GitHubActionsServiceFacade, WebContainerCommand, WebContainerRunCommandInput, WebContainerRuntime, WebContainerServiceDefinition, WebContainerServiceFacade, WorkflowRun, resolveDevelopmentCommand } from './development/index.js';
+export { CodeDiagnosticsInput, CodeDiagnosticsResult, CodeDiagnosticsService, CodeValidationInput, CodeValidationResult, CodeValidationRuntime, CodeValidationServiceDefinition, CodeValidationServiceFacade, DevelopmentProvider, DevelopmentRequest, DevelopmentResult, DevelopmentRuntime, DevelopmentServiceContract, DevelopmentServiceDefinition, DevelopmentServiceFacade, DevelopmentTask, GitHubActionsClient, GitHubActionsConfig, GitHubActionsServiceDefinition, GitHubActionsServiceFacade, TYPESCRIPT_LANGUAGE_SERVER_PACKAGE, TYPESCRIPT_LANGUAGE_SERVER_VERSION, TypeScriptLanguageServerNotificationInput, TypeScriptLanguageServerRequestInput, TypeScriptLanguageServerResponse, TypeScriptLanguageServerServiceDefinition, TypeScriptLanguageServerServiceFacade, TypeScriptLanguageServerStartInput, TypeScriptLanguageServerStatus, ValidationDiagnostic, ValidationLayer, WebContainerCommand, WebContainerRunCommandInput, WebContainerRuntime, WebContainerServiceDefinition, WebContainerServiceFacade, WorkflowRun, codeDiagnosticsService, resolveDevelopmentCommand } from './development/index.js';
 export { EndpointDescriptor, IService, ProtocolAdapter, ServiceDefinition } from '@ultrst-armada/krnl';
 import 'react';
 

package/packages/backend/dist/index.js

@@ -195,17 +195,26 @@ import {
   resolveSystemDatabaseClusterNodes
 } from "./chunk-RCCQ7IRM.js";
 import {
+  CodeDiagnosticsService,
+  CodeValidationRuntime,
+  CodeValidationServiceDefinition,
+  CodeValidationServiceFacade,
   DevelopmentRuntime,
   DevelopmentServiceDefinition,
   DevelopmentServiceFacade,
   GitHubActionsClient,
   GitHubActionsServiceDefinition,
   GitHubActionsServiceFacade,
+  TYPESCRIPT_LANGUAGE_SERVER_PACKAGE,
+  TYPESCRIPT_LANGUAGE_SERVER_VERSION,
+  TypeScriptLanguageServerServiceDefinition,
+  TypeScriptLanguageServerServiceFacade,
   WebContainerRuntime,
   WebContainerServiceDefinition,
   WebContainerServiceFacade,
+  codeDiagnosticsService,
   resolveDevelopmentCommand
-} from "./chunk-OVTXAGL6.js";
+} from "./chunk-3HZYAZF4.js";
 import "./chunk-TY32TUNI.js";
 
 // src/data/BaseDataProvider.ts
@@ -4379,6 +4388,10 @@ export {
   CANONICAL_SRKL_URL,
   CallbackRegistry,
   CloudflareResourceFetcher,
+  CodeDiagnosticsService,
+  CodeValidationRuntime,
+  CodeValidationServiceDefinition,
+  CodeValidationServiceFacade,
   CompositeBackend,
   ConcurrencyConflictError,
   ConcurrencyManager,
@@ -4436,6 +4449,10 @@ export {
   StorageServiceFacade,
   SupabaseStorageAdapter,
   SyncEngine,
+  TYPESCRIPT_LANGUAGE_SERVER_PACKAGE,
+  TYPESCRIPT_LANGUAGE_SERVER_VERSION,
+  TypeScriptLanguageServerServiceDefinition,
+  TypeScriptLanguageServerServiceFacade,
   VercelResourceFetcher,
   WORKSPACE_ASSETS_ROOT,
   WORKSPACE_ROOT,
@@ -4460,6 +4477,7 @@ export {
   buildProjectObservability,
   buildProjectsList,
   cleanDbUrl,
+  codeDiagnosticsService,
   computeDeploymentFinalWeight,
   computeUsageWeightScore,
   configureStarterProjectTemplate,

package/packages/backend/kloks.manifest.json

@@ -258,6 +258,85 @@
       },
       "dependencies": [
         "github-actions",
+        "web-container",
+        "code-validation"
+      ]
+    },
+    {
+      "id": "code-validation",
+      "name": "Code Validation & Diagnostics",
+      "version": "1.0.0",
+      "description": "Shared syntax, lint, test, build, KrnlTS, FrnlTS and Law L9 validation pipeline backed by the canonical WebContainer runtime; diagnostics are consumable by IDEs and agents.",
+      "backend": {
+        "package": "@ultrst-armada/kloks",
+        "subpath": "development",
+        "export": "CodeValidationServiceFacade",
+        "facade": "CodeValidationServiceFacade"
+      },
+      "modes": [
+        "fullstack"
+      ],
+      "targets": {
+        "backend": [
+          "App.main-content"
+        ],
+        "frontend": [
+          "App.main-content"
+        ]
+      },
+      "dependencies": [
+        "web-container"
+      ]
+    },
+    {
+      "id": "code-diagnostics",
+      "name": "TypeScript Code Diagnostics",
+      "version": "1.0.0",
+      "description": "Editor-facing TypeScript diagnostics runner for authored source.",
+      "backend": {
+        "package": "@ultrst-armada/kloks",
+        "subpath": "development",
+        "export": "codeDiagnosticsService",
+        "facade": "codeDiagnosticsService"
+      },
+      "modes": [
+        "fullstack"
+      ],
+      "targets": {
+        "backend": [
+          "App.main-content"
+        ],
+        "frontend": [
+          "App.main-content"
+        ]
+      },
+      "dependencies": [
+        "web-container"
+      ]
+    },
+    {
+      "id": "typescript-language-server",
+      "name": "TypeScript Language Server",
+      "version": "1.0.0",
+      "description": "Reusable TypeScript Language Server Protocol service provisioned into a development runtime and consumable by IDEs and agents.",
+      "backend": {
+        "package": "@ultrst-armada/kloks",
+        "subpath": "development",
+        "export": "TypeScriptLanguageServerServiceFacade",
+        "facade": "TypeScriptLanguageServerServiceFacade"
+      },
+      "modes": [
+        "fullstack"
+      ],
+      "targets": {
+        "backend": [
+          "App.main-content"
+        ],
+        "frontend": [
+          "App.main-content"
+        ]
+      },
+      "dependencies": [
         "web-container"
       ]
     }

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

@@ -7,21 +7,6 @@ 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,
@@ -45,6 +30,21 @@ 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,