@ultrst-armada/kloks 1.4.8 → 1.5.1

package/.krusbl-release-attestation.json

@@ -1,8 +1,8 @@
 {
   "schema": 1,
   "packageName": "@ultrst-armada/kloks",
-  "version": "1.4.8",
-  "sourceCommit": "6ab0d5dfede2344d9dd35ce366b67ac44b808401",
+  "version": "1.5.1",
+  "sourceCommit": "df4285ad26bbf5f16acaca63ba43fe4e40740051",
   "releaseWorkflow": "npm Release",
-  "workflowRunId": "39557640590"
+  "workflowRunId": "39943915592"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ultrst-armada/kloks",
-  "version": "1.4.8",
+  "version": "1.5.1",
   "private": false,
   "publishConfig": {
     "access": "public",
@@ -104,6 +104,11 @@
       "types": "./packages/client/dist/index.d.ts",
       "import": "./packages/client/dist/index.js",
       "default": "./packages/client/dist/index.js"
+    },
+    "./development": {
+      "types": "./packages/backend/dist/development/index.d.ts",
+      "import": "./packages/backend/dist/development/index.js",
+      "default": "./packages/backend/dist/development/index.js"
     }
   },
   "scripts": {
@@ -119,7 +124,8 @@
     "bcryptjs": "^2.4.3",
     "ws": "^8.18.0",
     "zod": "^3.24.1",
-    "zustand": "^5.0.15"
+    "zustand": "^5.0.15",
+    "@webcontainer/api": "^1.6.4"
   },
   "peerDependencies": {
     "@neondatabase/serverless": "^0.10.0 || ^1.0.0",

package/packages/backend/dist/chunk-DBZVGMJ7.js

@@ -0,0 +1,159 @@
+import {
+  StorageAdapterFactory
+} from "./chunk-J2J24JVC.js";
+import {
+  findUserWorkspace
+} from "./chunk-E72GXBXF.js";
+
+// src/services/workspaceGraphService.ts
+function slugify(name) {
+  const value = String(name || "").trim().replace(/[/\\]+/g, "_").replace(/[<>:"|?*]/g, "").slice(0, 80);
+  return value || "New Graph";
+}
+function storage() {
+  return StorageAdapterFactory.create({
+    provider: "local_fs",
+    basePath: process.env.KLOKS_GRAPH_STORAGE_ROOT || "./workspaces-data"
+  });
+}
+function graphPath(workspaceId, slug) {
+  return `workspaces/${workspaceId}/graphs/${slug}.graph.json`;
+}
+async function assertWorkspace(userId, workspaceId) {
+  const result = await findUserWorkspace(workspaceId);
+  if (!result.workspace || !result.user || result.user.id !== userId) {
+    throw new Error(`Workspace ${workspaceId} does not exist`);
+  }
+  return result.workspace;
+}
+async function readGraph(workspaceId, slug) {
+  const adapter = storage();
+  const path = graphPath(workspaceId, slug);
+  if (!await adapter.exists(path)) return null;
+  const raw = new TextDecoder().decode(await adapter.read(path));
+  return JSON.parse(raw);
+}
+async function writeGraph(document) {
+  const adapter = storage();
+  await adapter.write(graphPath(document.workspaceId, document.graphSlug), JSON.stringify(document, null, 2), "application/json");
+}
+function toDocument(workspaceId, id, name, slug, nodes = [], edges = [], createdAt = (/* @__PURE__ */ new Date()).toISOString()) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    $schema: "https://skipo.dev/schemas/node-graph.v1.json",
+    version: "1.0.0",
+    appId: workspaceId,
+    appName: name,
+    createdAt,
+    updatedAt: now,
+    exportedAt: now,
+    workspaceId,
+    graphId: id,
+    graphSlug: slug,
+    graph: { nodes, edges }
+  };
+}
+var workspaceGraphService = {
+  async listGraphs(userId, workspaceId) {
+    await assertWorkspace(userId, workspaceId);
+    const adapter = storage();
+    const files = await adapter.list(`workspaces/${workspaceId}/graphs`);
+    const graphs = [];
+    for (const file of files.filter((item) => item.path.endsWith(".graph.json"))) {
+      try {
+        const raw = new TextDecoder().decode(await adapter.read(file.path));
+        const graph = JSON.parse(raw);
+        graphs.push({
+          id: graph.graphId,
+          name: graph.appName,
+          slug: graph.graphSlug,
+          createdAt: graph.createdAt,
+          updatedAt: graph.updatedAt,
+          nodeCount: graph.graph.nodes.length
+        });
+      } catch {
+      }
+    }
+    graphs.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+    return { success: true, graphs };
+  },
+  async createGraph(userId, workspaceId, input) {
+    await assertWorkspace(userId, workspaceId);
+    const targetName = String(input?.name || "").trim().slice(0, 80) || "New Graph";
+    const baseSlug = slugify(targetName);
+    let slug = baseSlug;
+    let n = 2;
+    while (await readGraph(workspaceId, slug)) slug = `${baseSlug} (${n++})`;
+    const graph = toDocument(workspaceId, `graph-${Date.now()}`, targetName, slug);
+    await writeGraph(graph);
+    return { success: true, graph, graphs: (await this.listGraphs(userId, workspaceId)).graphs };
+  },
+  async getGraph(userId, workspaceId, slug) {
+    await assertWorkspace(userId, workspaceId);
+    const graph = await readGraph(workspaceId, slug);
+    if (!graph) throw new Error(`Graph "${slug}" not found`);
+    return { success: true, graph };
+  },
+  async saveGraph(userId, workspaceId, slug, patch) {
+    await assertWorkspace(userId, workspaceId);
+    const existing = await readGraph(workspaceId, slug);
+    if (!existing) throw new Error(`Graph "${slug}" not found`);
+    const next = {
+      ...existing,
+      appName: typeof patch.name === "string" && patch.name.trim() ? patch.name.trim().slice(0, 80) : existing.appName,
+      graph: {
+        nodes: Array.isArray(patch.nodes) ? patch.nodes : existing.graph.nodes,
+        edges: Array.isArray(patch.edges) ? patch.edges : existing.graph.edges
+      },
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      exportedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    await writeGraph(next);
+    return { success: true, graph: next };
+  },
+  async deleteGraph(userId, workspaceId, slug) {
+    await assertWorkspace(userId, workspaceId);
+    const adapter = storage();
+    const path = graphPath(workspaceId, slug);
+    if (!await adapter.exists(path)) throw new Error(`Graph "${slug}" not found`);
+    await adapter.delete(path);
+    return { success: true, deletedSlug: slug, graphs: (await this.listGraphs(userId, workspaceId)).graphs };
+  },
+  async duplicateGraph(userId, workspaceId, slug, newName) {
+    const existing = (await this.getGraph(userId, workspaceId, slug)).graph;
+    const targetName = (newName || `${existing.appName} (Copy)`).trim().slice(0, 80);
+    const baseSlug = slugify(targetName);
+    let newSlug = baseSlug;
+    let n = 2;
+    while (await readGraph(workspaceId, newSlug)) newSlug = `${baseSlug} (${n++})`;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const graph = {
+      ...JSON.parse(JSON.stringify(existing)),
+      graphId: `graph-${Date.now()}`,
+      graphSlug: newSlug,
+      appName: targetName,
+      createdAt: now,
+      updatedAt: now,
+      exportedAt: now
+    };
+    await writeGraph(graph);
+    return { success: true, graph, graphs: (await this.listGraphs(userId, workspaceId)).graphs };
+  },
+  async clearGraph(userId, workspaceId, slug) {
+    const existing = (await this.getGraph(userId, workspaceId, slug)).graph;
+    return this.saveGraph(userId, workspaceId, slug, { nodes: [], edges: [] });
+  },
+  async getGraphDocument(userId, workspaceId, slug) {
+    return (await this.getGraph(userId, workspaceId, slug)).graph;
+  },
+  async saveGraphDocument(userId, workspaceId, document) {
+    await assertWorkspace(userId, workspaceId);
+    if (document.workspaceId !== workspaceId) throw new Error("Graph workspace mismatch");
+    await writeGraph({ ...document, updatedAt: (/* @__PURE__ */ new Date()).toISOString(), exportedAt: (/* @__PURE__ */ new Date()).toISOString() });
+    return { success: true, graph: document };
+  }
+};
+
+export {
+  workspaceGraphService
+};

package/packages/backend/dist/{chunk-KYBO7FGP.js → chunk-GQUNN7SA.js}

@@ -1,7 +1,13 @@
+import {
+  workspaceGraphService
+} from "./chunk-DBZVGMJ7.js";
 import {
   getSrklAccounts,
   srklListBackblazeBuckets
 } from "./chunk-VDROUXFT.js";
+import {
+  StorageAdapterFactory
+} from "./chunk-J2J24JVC.js";
 import {
   b2ListBuckets
 } from "./chunk-4QEMALXF.js";
@@ -9,20 +15,6 @@ import {
   formatCanonicalWorkspaceFolderName,
   sanitizeWorkspaceName
 } from "./chunk-FZKBTF34.js";
-import {
-  RateLimiter,
-  SessionManager,
-  loginSystemUser,
-  resolveUserFromToken
-} from "./chunk-ZDH4XI7W.js";
-import {
-  createService,
-  createServiceDefinition,
-  workspaceGraphService
-} from "./chunk-ZFCEXTNI.js";
-import {
-  StorageAdapterFactory
-} from "./chunk-J2J24JVC.js";
 import {
   createWorkspace,
   deleteWorkspace,
@@ -31,6 +23,16 @@ import {
   queryUnifiedDb,
   updateWorkspace
 } from "./chunk-E72GXBXF.js";
+import {
+  RateLimiter,
+  SessionManager,
+  loginSystemUser,
+  resolveUserFromToken
+} from "./chunk-ZDH4XI7W.js";
+import {
+  createService,
+  createServiceDefinition
+} from "./chunk-TY32TUNI.js";
 
 // src/krnl-services.ts
 var AuthServiceDefinition = createServiceDefinition({

package/packages/backend/dist/chunk-OVTXAGL6.js

@@ -0,0 +1,298 @@
+import {
+  createService,
+  createServiceDefinition
+} from "./chunk-TY32TUNI.js";
+
+// src/development/githubActionsService.ts
+var GitHubActionsClient = class {
+  constructor(config) {
+    this.config = config;
+    this.baseUrl = config.apiBaseUrl ?? "https://api.github.com";
+    this.fetchImpl = config.fetchImpl ?? fetch;
+  }
+  config;
+  baseUrl;
+  fetchImpl;
+  async request(path, init = {}) {
+    const response = await this.fetchImpl(this.baseUrl + path, {
+      ...init,
+      headers: {
+        Accept: "application/vnd.github+json",
+        Authorization: `Bearer ${this.config.token}`,
+        "X-GitHub-Api-Version": "2022-11-28",
+        ...init.headers ?? {}
+      }
+    });
+    const text = await response.text();
+    const data = text ? JSON.parse(text) : void 0;
+    if (!response.ok) {
+      throw new Error(`GitHub Actions request failed (${response.status}): ${data?.message ?? response.statusText}`);
+    }
+    return data;
+  }
+  listWorkflowRuns(repository, workflowId, branch) {
+    const suffix = workflowId ? `/actions/workflows/${workflowId}/runs` : "/actions/runs";
+    const query = branch ? `?branch=${encodeURIComponent(branch)}` : "";
+    return this.request(`/repos/${repository}${suffix}${query}`);
+  }
+  getWorkflowRun(repository, runId) {
+    return this.request(`/repos/${repository}/actions/runs/${runId}`);
+  }
+  getWorkflowJobs(repository, runId) {
+    return this.request(
+      `/repos/${repository}/actions/runs/${runId}/jobs`
+    );
+  }
+  getJobLogs(repository, jobId) {
+    return this.request(`/repos/${repository}/actions/jobs/${jobId}/logs`);
+  }
+  listArtifacts(repository, runId) {
+    const path = runId ? `/repos/${repository}/actions/runs/${runId}/artifacts` : `/repos/${repository}/actions/artifacts`;
+    return this.request(path);
+  }
+  dispatchWorkflow(repository, workflowId, ref, inputs = {}) {
+    return this.request(`/repos/${repository}/actions/workflows/${workflowId}/dispatches`, {
+      method: "POST",
+      body: JSON.stringify({ ref, inputs }),
+      headers: { "Content-Type": "application/json" }
+    });
+  }
+  rerunWorkflow(repository, runId) {
+    return this.request(`/repos/${repository}/actions/runs/${runId}/rerun`, { method: "POST" });
+  }
+  rerunFailedJobs(repository, runId) {
+    return this.request(`/repos/${repository}/actions/runs/${runId}/rerun-failed-jobs`, { method: "POST" });
+  }
+  cancelWorkflow(repository, runId) {
+    return this.request(`/repos/${repository}/actions/runs/${runId}/cancel`, { method: "POST" });
+  }
+};
+var GitHubActionsServiceDefinition = createServiceDefinition({
+  id: "kloks.backend.githubActions",
+  name: "GitHubActionsService",
+  version: "1.0.0",
+  operations: {
+    listWorkflowRuns: { id: "GitHubActionsService.listWorkflowRuns", name: "listWorkflowRuns", handler: async (i) => new GitHubActionsClient({ token: i.token }).listWorkflowRuns(i.repository, i.workflowId, i.branch) },
+    getWorkflowRun: { id: "GitHubActionsService.getWorkflowRun", name: "getWorkflowRun", handler: async (i) => new GitHubActionsClient({ token: i.token }).getWorkflowRun(i.repository, i.runId) },
+    getWorkflowJobs: { id: "GitHubActionsService.getWorkflowJobs", name: "getWorkflowJobs", handler: async (i) => new GitHubActionsClient({ token: i.token }).getWorkflowJobs(i.repository, i.runId) },
+    getJobLogs: { id: "GitHubActionsService.getJobLogs", name: "getJobLogs", handler: async (i) => new GitHubActionsClient({ token: i.token }).getJobLogs(i.repository, i.jobId) },
+    listArtifacts: { id: "GitHubActionsService.listArtifacts", name: "listArtifacts", handler: async (i) => new GitHubActionsClient({ token: i.token }).listArtifacts(i.repository, i.runId) },
+    dispatchWorkflow: { id: "GitHubActionsService.dispatchWorkflow", name: "dispatchWorkflow", handler: async (i) => new GitHubActionsClient({ token: i.token }).dispatchWorkflow(i.repository, i.workflowId, i.ref, i.inputs) },
+    rerunWorkflow: { id: "GitHubActionsService.rerunWorkflow", name: "rerunWorkflow", handler: async (i) => new GitHubActionsClient({ token: i.token }).rerunWorkflow(i.repository, i.runId) },
+    rerunFailedJobs: { id: "GitHubActionsService.rerunFailedJobs", name: "rerunFailedJobs", handler: async (i) => new GitHubActionsClient({ token: i.token }).rerunFailedJobs(i.repository, i.runId) },
+    cancelWorkflow: { id: "GitHubActionsService.cancelWorkflow", name: "cancelWorkflow", handler: async (i) => new GitHubActionsClient({ token: i.token }).cancelWorkflow(i.repository, i.runId) }
+  }
+});
+var GitHubActionsServiceFacade = {
+  id: GitHubActionsServiceDefinition.id,
+  name: GitHubActionsServiceDefinition.name,
+  version: GitHubActionsServiceDefinition.version,
+  runtime: "server",
+  deployment: "remote",
+  definition: GitHubActionsServiceDefinition,
+  createInstance: () => createService(GitHubActionsServiceDefinition),
+  execute: async (op, input) => {
+    const instance = createService(GitHubActionsServiceDefinition);
+    await instance.start();
+    return instance.call(op, input);
+  }
+};
+
+// src/development/webContainerService.ts
+var COMMANDS = {
+  install: { command: "pnpm", args: ["install", "--no-frozen-lockfile"] },
+  lint: { command: "pnpm", args: ["lint"] },
+  test: { command: "pnpm", args: ["test"] },
+  build: { command: "pnpm", args: ["build"] },
+  validate: { command: "pnpm", args: ["lint"] },
+  check: { command: "pnpm", args: ["lint"] }
+};
+var runQueue = Promise.resolve();
+var WebContainerRuntime = class {
+  container = null;
+  instancePromise = null;
+  async boot() {
+    if (typeof window !== "undefined" && !window.crossOriginIsolated) {
+      throw new Error("WebContainer requires a cross-origin-isolated page. Ensure COOP=same-origin and COEP=require-corp are served.");
+    }
+    if (this.container) return this.container;
+    if (!this.instancePromise) {
+      this.instancePromise = import("@webcontainer/api").then(async (module) => {
+        const container = await module.WebContainer.boot({
+          coep: "require-corp",
+          workdirName: "kloks-development"
+        });
+        this.container = container;
+        return container;
+      }).catch((error) => {
+        this.instancePromise = null;
+        throw error;
+      });
+    }
+    return this.instancePromise;
+  }
+  async mount(files) {
+    const container = await this.boot();
+    await container.mount(files);
+    return { mounted: true };
+  }
+  async runProcess(command, args, cwd, env) {
+    const container = await this.boot();
+    const process = await container.spawn(command, args, { cwd, env });
+    let output = "";
+    const reader = process.output.getReader();
+    try {
+      while (true) {
+        const next = await reader.read();
+        if (next.done) break;
+        output += next.value;
+      }
+    } finally {
+      reader.releaseLock();
+    }
+    return { exitCode: await process.exit, output };
+  }
+  async run(task, cwd, env) {
+    const spec = COMMANDS[task];
+    return this.runCommand(spec.command, spec.args, cwd, env);
+  }
+  async runCommand(command, args = [], cwd, env) {
+    const previous = runQueue;
+    let release;
+    runQueue = new Promise((resolve) => {
+      release = resolve;
+    });
+    await previous;
+    try {
+      return await this.runProcess(command, args, cwd, env);
+    } finally {
+      release();
+    }
+  }
+  async teardown() {
+    const container = this.container;
+    this.container = null;
+    this.instancePromise = null;
+    container?.teardown();
+    return { tornDown: true };
+  }
+};
+var runtime = new WebContainerRuntime();
+var WebContainerServiceDefinition = createServiceDefinition({
+  id: "kloks.backend.webContainer",
+  name: "WebContainerService",
+  version: "1.1.0",
+  operations: {
+    boot: { id: "WebContainerService.boot", name: "boot", handler: async () => {
+      await runtime.boot();
+      return { ready: true };
+    } },
+    mount: { id: "WebContainerService.mount", name: "mount", handler: async (input) => runtime.mount(input.files) },
+    run: { id: "WebContainerService.run", name: "run", handler: async (input) => runtime.run(input.task, input.cwd, input.env) },
+    runCommand: { id: "WebContainerService.runCommand", name: "runCommand", handler: async (input) => runtime.runCommand(input.command, input.args, input.cwd, input.env) },
+    teardown: { id: "WebContainerService.teardown", name: "teardown", handler: async () => runtime.teardown() },
+    command: { id: "WebContainerService.command", name: "command", handler: async (input) => ({ task: input.task, command: COMMANDS[input.task] }) }
+  }
+});
+var WebContainerServiceFacade = {
+  id: WebContainerServiceDefinition.id,
+  name: WebContainerServiceDefinition.name,
+  version: WebContainerServiceDefinition.version,
+  runtime: "client",
+  deployment: "local",
+  definition: WebContainerServiceDefinition,
+  createInstance: () => createService(WebContainerServiceDefinition),
+  execute: async (op, input) => {
+    const instance = createService(WebContainerServiceDefinition);
+    await instance.start();
+    return instance.call(op, input);
+  }
+};
+
+// src/development/developmentService.ts
+function resolveDevelopmentCommand(task) {
+  const commands = {
+    install: ["pnpm", ["install", "--no-frozen-lockfile"]],
+    lint: ["pnpm", ["lint"]],
+    test: ["pnpm", ["test"]],
+    build: ["pnpm", ["build"]],
+    validate: ["pnpm", ["validate"]],
+    check: ["pnpm", ["lint"]]
+  };
+  return commands[task];
+}
+var DevelopmentServiceDefinition = createServiceDefinition({
+  id: "kloks.backend.development",
+  name: "DevelopmentService",
+  version: "1.0.0",
+  operations: {
+    plan: {
+      id: "DevelopmentService.plan",
+      name: "plan",
+      handler: async (input) => {
+        const [command, args] = resolveDevelopmentCommand(input.task);
+        return { task: input.task, command, args };
+      }
+    },
+    describeProviders: {
+      id: "DevelopmentService.describeProviders",
+      name: "describeProviders",
+      handler: async () => ({
+        providers: [
+          { id: "webcontainer", capabilities: ["install", "lint", "test", "build", "validate", "check"] },
+          { id: "github-actions", capabilities: ["dispatch", "observe", "rerun", "cancel"] }
+        ]
+      })
+    }
+  }
+});
+var DevelopmentRuntime = class {
+  constructor(webContainer = new WebContainerRuntime(), githubActions) {
+    this.webContainer = webContainer;
+    this.githubActions = githubActions;
+  }
+  webContainer;
+  githubActions;
+  async run(request) {
+    if (request.provider === "webcontainer") {
+      const [command, args] = resolveDevelopmentCommand(request.task);
+      const result = await this.webContainer.run(request.task, request.cwd, request.env);
+      return { provider: request.provider, task: request.task, ok: result.exitCode === 0, exitCode: result.exitCode, output: result.output };
+    }
+    if (!this.githubActions || !request.repository || !request.workflowId || !request.ref) {
+      throw new Error("GitHub Actions execution requires repository, workflowId, ref, and an authenticated client");
+    }
+    await this.githubActions.dispatchWorkflow(request.repository, request.workflowId, request.ref, {
+      task: request.task,
+      ...request.workflowInputs ?? {}
+    });
+    return { provider: request.provider, task: request.task, ok: true, output: "Workflow dispatched; observe its run for final status." };
+  }
+};
+var DevelopmentServiceFacade = {
+  id: DevelopmentServiceDefinition.id,
+  name: DevelopmentServiceDefinition.name,
+  version: DevelopmentServiceDefinition.version,
+  runtime: "server",
+  deployment: "local",
+  definition: DevelopmentServiceDefinition,
+  createInstance: () => createService(DevelopmentServiceDefinition),
+  execute: async (op, input) => {
+    const instance = createService(DevelopmentServiceDefinition);
+    await instance.start();
+    return instance.call(op, input);
+  }
+};
+
+export {
+  GitHubActionsClient,
+  GitHubActionsServiceDefinition,
+  GitHubActionsServiceFacade,
+  WebContainerRuntime,
+  WebContainerServiceDefinition,
+  WebContainerServiceFacade,
+  resolveDevelopmentCommand,
+  DevelopmentServiceDefinition,
+  DevelopmentRuntime,
+  DevelopmentServiceFacade
+};

package/packages/backend/dist/{chunk-R27SHBHK.js → chunk-RBF2OGMC.js}

@@ -2,7 +2,7 @@ import {
   createService,
   createServiceDefinition,
   createServiceProxy
-} from "./chunk-ZFCEXTNI.js";
+} from "./chunk-TY32TUNI.js";
 
 // src/services/ServiceBoundary.ts
 function createLocalService(definition) {

package/packages/backend/dist/{chunk-ZFCEXTNI.js → chunk-TY32TUNI.js}

@@ -1,10 +1,3 @@
-import {
-  StorageAdapterFactory
-} from "./chunk-J2J24JVC.js";
-import {
-  findUserWorkspace
-} from "./chunk-E72GXBXF.js";
-
 // ../../node_modules/.pnpm/@ultrst-armada+krnl@1.0.3/node_modules/@ultrst-armada/krnl/packages/core/dist/index.js
 var ServiceStateStore = class {
   state;
@@ -376,158 +369,8 @@ function createServiceProxy(definition, adapter, endpoint) {
 }
 var asyncHooks = globalThis.process?.getBuiltinModule?.("node:async_hooks");
 
-// src/services/workspaceGraphService.ts
-function slugify(name) {
-  const value = String(name || "").trim().replace(/[/\\]+/g, "_").replace(/[<>:"|?*]/g, "").slice(0, 80);
-  return value || "New Graph";
-}
-function storage() {
-  return StorageAdapterFactory.create({
-    provider: "local_fs",
-    basePath: process.env.KLOKS_GRAPH_STORAGE_ROOT || "./workspaces-data"
-  });
-}
-function graphPath(workspaceId, slug) {
-  return `workspaces/${workspaceId}/graphs/${slug}.graph.json`;
-}
-async function assertWorkspace(userId, workspaceId) {
-  const result = await findUserWorkspace(workspaceId);
-  if (!result.workspace || !result.user || result.user.id !== userId) {
-    throw new Error(`Workspace ${workspaceId} does not exist`);
-  }
-  return result.workspace;
-}
-async function readGraph(workspaceId, slug) {
-  const adapter = storage();
-  const path = graphPath(workspaceId, slug);
-  if (!await adapter.exists(path)) return null;
-  const raw = new TextDecoder().decode(await adapter.read(path));
-  return JSON.parse(raw);
-}
-async function writeGraph(document) {
-  const adapter = storage();
-  await adapter.write(graphPath(document.workspaceId, document.graphSlug), JSON.stringify(document, null, 2), "application/json");
-}
-function toDocument(workspaceId, id, name, slug, nodes = [], edges = [], createdAt = (/* @__PURE__ */ new Date()).toISOString()) {
-  const now = (/* @__PURE__ */ new Date()).toISOString();
-  return {
-    $schema: "https://skipo.dev/schemas/node-graph.v1.json",
-    version: "1.0.0",
-    appId: workspaceId,
-    appName: name,
-    createdAt,
-    updatedAt: now,
-    exportedAt: now,
-    workspaceId,
-    graphId: id,
-    graphSlug: slug,
-    graph: { nodes, edges }
-  };
-}
-var workspaceGraphService = {
-  async listGraphs(userId, workspaceId) {
-    await assertWorkspace(userId, workspaceId);
-    const adapter = storage();
-    const files = await adapter.list(`workspaces/${workspaceId}/graphs`);
-    const graphs = [];
-    for (const file of files.filter((item) => item.path.endsWith(".graph.json"))) {
-      try {
-        const raw = new TextDecoder().decode(await adapter.read(file.path));
-        const graph = JSON.parse(raw);
-        graphs.push({
-          id: graph.graphId,
-          name: graph.appName,
-          slug: graph.graphSlug,
-          createdAt: graph.createdAt,
-          updatedAt: graph.updatedAt,
-          nodeCount: graph.graph.nodes.length
-        });
-      } catch {
-      }
-    }
-    graphs.sort((a, b) => a.createdAt.localeCompare(b.createdAt));
-    return { success: true, graphs };
-  },
-  async createGraph(userId, workspaceId, input) {
-    await assertWorkspace(userId, workspaceId);
-    const targetName = String(input?.name || "").trim().slice(0, 80) || "New Graph";
-    const baseSlug = slugify(targetName);
-    let slug = baseSlug;
-    let n = 2;
-    while (await readGraph(workspaceId, slug)) slug = `${baseSlug} (${n++})`;
-    const graph = toDocument(workspaceId, `graph-${Date.now()}`, targetName, slug);
-    await writeGraph(graph);
-    return { success: true, graph, graphs: (await this.listGraphs(userId, workspaceId)).graphs };
-  },
-  async getGraph(userId, workspaceId, slug) {
-    await assertWorkspace(userId, workspaceId);
-    const graph = await readGraph(workspaceId, slug);
-    if (!graph) throw new Error(`Graph "${slug}" not found`);
-    return { success: true, graph };
-  },
-  async saveGraph(userId, workspaceId, slug, patch) {
-    await assertWorkspace(userId, workspaceId);
-    const existing = await readGraph(workspaceId, slug);
-    if (!existing) throw new Error(`Graph "${slug}" not found`);
-    const next = {
-      ...existing,
-      appName: typeof patch.name === "string" && patch.name.trim() ? patch.name.trim().slice(0, 80) : existing.appName,
-      graph: {
-        nodes: Array.isArray(patch.nodes) ? patch.nodes : existing.graph.nodes,
-        edges: Array.isArray(patch.edges) ? patch.edges : existing.graph.edges
-      },
-      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
-      exportedAt: (/* @__PURE__ */ new Date()).toISOString()
-    };
-    await writeGraph(next);
-    return { success: true, graph: next };
-  },
-  async deleteGraph(userId, workspaceId, slug) {
-    await assertWorkspace(userId, workspaceId);
-    const adapter = storage();
-    const path = graphPath(workspaceId, slug);
-    if (!await adapter.exists(path)) throw new Error(`Graph "${slug}" not found`);
-    await adapter.delete(path);
-    return { success: true, deletedSlug: slug, graphs: (await this.listGraphs(userId, workspaceId)).graphs };
-  },
-  async duplicateGraph(userId, workspaceId, slug, newName) {
-    const existing = (await this.getGraph(userId, workspaceId, slug)).graph;
-    const targetName = (newName || `${existing.appName} (Copy)`).trim().slice(0, 80);
-    const baseSlug = slugify(targetName);
-    let newSlug = baseSlug;
-    let n = 2;
-    while (await readGraph(workspaceId, newSlug)) newSlug = `${baseSlug} (${n++})`;
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    const graph = {
-      ...JSON.parse(JSON.stringify(existing)),
-      graphId: `graph-${Date.now()}`,
-      graphSlug: newSlug,
-      appName: targetName,
-      createdAt: now,
-      updatedAt: now,
-      exportedAt: now
-    };
-    await writeGraph(graph);
-    return { success: true, graph, graphs: (await this.listGraphs(userId, workspaceId)).graphs };
-  },
-  async clearGraph(userId, workspaceId, slug) {
-    const existing = (await this.getGraph(userId, workspaceId, slug)).graph;
-    return this.saveGraph(userId, workspaceId, slug, { nodes: [], edges: [] });
-  },
-  async getGraphDocument(userId, workspaceId, slug) {
-    return (await this.getGraph(userId, workspaceId, slug)).graph;
-  },
-  async saveGraphDocument(userId, workspaceId, document) {
-    await assertWorkspace(userId, workspaceId);
-    if (document.workspaceId !== workspaceId) throw new Error("Graph workspace mismatch");
-    await writeGraph({ ...document, updatedAt: (/* @__PURE__ */ new Date()).toISOString(), exportedAt: (/* @__PURE__ */ new Date()).toISOString() });
-    return { success: true, graph: document };
-  }
-};
-
 export {
   createServiceDefinition,
   createService,
-  createServiceProxy,
-  workspaceGraphService
+  createServiceProxy
 };

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

@@ -0,0 +1,146 @@
+import * as _ultrst_armada_krnl from '@ultrst-armada/krnl';
+import { ServiceDefinition } from '@ultrst-armada/krnl';
+
+type DevelopmentProvider = 'webcontainer' | 'github-actions';
+type DevelopmentTask = 'install' | 'lint' | 'test' | 'build' | 'validate' | 'check';
+interface DevelopmentRequest {
+    provider: DevelopmentProvider;
+    task: DevelopmentTask;
+    repository?: string;
+    ref?: string;
+    workflowId?: string | number;
+    workflowInputs?: Record<string, string>;
+    cwd?: string;
+    env?: Record<string, string>;
+}
+interface DevelopmentResult {
+    provider: DevelopmentProvider;
+    task: DevelopmentTask;
+    ok: boolean;
+    exitCode?: number;
+    output?: string;
+    runId?: number;
+    url?: string;
+}
+interface WebContainerCommand {
+    command: string;
+    args: string[];
+}
+interface DevelopmentServiceContract {
+    definition: ServiceDefinition;
+}
+
+interface GitHubActionsConfig {
+    token: string;
+    apiBaseUrl?: string;
+    fetchImpl?: typeof fetch;
+}
+interface WorkflowRun {
+    id: number;
+    name?: string;
+    status?: string;
+    conclusion?: string | null;
+    html_url?: string;
+}
+declare class GitHubActionsClient {
+    private readonly config;
+    private readonly baseUrl;
+    private readonly fetchImpl;
+    constructor(config: GitHubActionsConfig);
+    private request;
+    listWorkflowRuns(repository: string, workflowId?: string | number, branch?: string): Promise<{
+        workflow_runs: WorkflowRun[];
+    }>;
+    getWorkflowRun(repository: string, runId: number): Promise<WorkflowRun>;
+    getWorkflowJobs(repository: string, runId: number): Promise<{
+        jobs: Array<{
+            id: number;
+            name: string;
+            status: string;
+            conclusion?: string | null;
+        }>;
+    }>;
+    getJobLogs(repository: string, jobId: number): Promise<string>;
+    listArtifacts(repository: string, runId?: number): Promise<{
+        artifacts: Array<{
+            id: number;
+            name: string;
+            expired: boolean;
+        }>;
+    }>;
+    dispatchWorkflow(repository: string, workflowId: string | number, ref: string, inputs?: Record<string, string>): Promise<void>;
+    rerunWorkflow(repository: string, runId: number): Promise<void>;
+    rerunFailedJobs(repository: string, runId: number): Promise<void>;
+    cancelWorkflow(repository: string, runId: number): Promise<void>;
+}
+declare const GitHubActionsServiceDefinition: ServiceDefinition;
+declare const GitHubActionsServiceFacade: {
+    id: string;
+    name: string;
+    version: string;
+    runtime: "server";
+    deployment: "remote";
+    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>;
+};
+
+declare const COMMANDS: Record<string, WebContainerCommand>;
+interface WebContainerRunCommandInput {
+    command: string;
+    args?: string[];
+    cwd?: string;
+    env?: Record<string, string | number | boolean>;
+}
+declare class WebContainerRuntime {
+    private container;
+    private instancePromise;
+    boot(): Promise<any>;
+    mount(files: Record<string, unknown>): Promise<{
+        mounted: boolean;
+    }>;
+    private runProcess;
+    run(task: keyof typeof COMMANDS, cwd?: string, env?: Record<string, string>): Promise<{
+        exitCode: any;
+        output: string;
+    }>;
+    runCommand(command: string, args?: string[], cwd?: string, env?: Record<string, string | number | boolean>): Promise<{
+        exitCode: any;
+        output: string;
+    }>;
+    teardown(): Promise<{
+        tornDown: boolean;
+    }>;
+}
+declare const WebContainerServiceDefinition: ServiceDefinition;
+declare const WebContainerServiceFacade: {
+    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>;
+};
+
+declare function resolveDevelopmentCommand(task: DevelopmentRequest['task']): [string, string[]];
+declare const DevelopmentServiceDefinition: ServiceDefinition;
+declare class DevelopmentRuntime {
+    private readonly webContainer;
+    private readonly githubActions?;
+    constructor(webContainer?: WebContainerRuntime, githubActions?: GitHubActionsClient);
+    run(request: DevelopmentRequest): Promise<DevelopmentResult>;
+}
+declare const DevelopmentServiceFacade: {
+    id: string;
+    name: string;
+    version: string;
+    runtime: "server";
+    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 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 };

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

@@ -0,0 +1,25 @@
+import {
+  DevelopmentRuntime,
+  DevelopmentServiceDefinition,
+  DevelopmentServiceFacade,
+  GitHubActionsClient,
+  GitHubActionsServiceDefinition,
+  GitHubActionsServiceFacade,
+  WebContainerRuntime,
+  WebContainerServiceDefinition,
+  WebContainerServiceFacade,
+  resolveDevelopmentCommand
+} from "../chunk-OVTXAGL6.js";
+import "../chunk-TY32TUNI.js";
+export {
+  DevelopmentRuntime,
+  DevelopmentServiceDefinition,
+  DevelopmentServiceFacade,
+  GitHubActionsClient,
+  GitHubActionsServiceDefinition,
+  GitHubActionsServiceFacade,
+  WebContainerRuntime,
+  WebContainerServiceDefinition,
+  WebContainerServiceFacade,
+  resolveDevelopmentCommand
+};

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

@@ -13,6 +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 { EndpointDescriptor, IService, ProtocolAdapter, ServiceDefinition } from '@ultrst-armada/krnl';
 import 'react';
 

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,
@@ -61,12 +75,30 @@ import {
   krnlWorkspaceGraphServiceFacade,
   krnlWorkspaceServiceDefinition,
   krnlWorkspaceServiceFacade
-} from "./chunk-KYBO7FGP.js";
+} from "./chunk-GQUNN7SA.js";
+import {
+  workspaceGraphService
+} from "./chunk-DBZVGMJ7.js";
 import {
   getPrimarySrklDeploymentUrl,
   getSrklAccounts,
   srklListBackblazeBuckets
 } from "./chunk-VDROUXFT.js";
+import {
+  BackblazeB2Adapter,
+  BaseStorageAdapter,
+  LocalFSAdapter,
+  S3Adapter,
+  StorageAdapterFactory,
+  SupabaseStorageAdapter,
+  ensureS3DirectoryMarker,
+  isSecretMasked,
+  normalizeBackblazeCredentials,
+  permanentDeleteS3Folder,
+  permanentDeleteS3Object,
+  renameS3Folder,
+  resolveBackblazeEndpoint
+} from "./chunk-J2J24JVC.js";
 import {
   authorizeB2,
   b2DownloadFile,
@@ -78,6 +110,35 @@ import {
   formatCanonicalWorkspaceFolderName,
   sanitizeWorkspaceName
 } from "./chunk-FZKBTF34.js";
+import {
+  b2DeleteFileVersion,
+  b2DeleteFolder,
+  b2ListBuckets as b2ListBuckets2,
+  cleanDbUrl,
+  createWorkspace,
+  deleteWorkspace,
+  deleteWorkspaceFile,
+  deleteWorkspaceFolder,
+  findUserWorkspace,
+  getB2BucketId,
+  getUnifiedDbUrl,
+  getWorkspaceFolderPrefix,
+  getWorkspaceStorageDetails,
+  getWorkspaces,
+  isB2Workspace,
+  listWorkspaceFiles,
+  loadWorkspaceData,
+  queryUnifiedDb,
+  readWorkspaceFile,
+  renameAppInWorkspaceData,
+  resolveWorkspaceConnection,
+  saveWorkspaceData,
+  syncWorkspaceCreateToBucket,
+  syncWorkspaceDataToBucket,
+  syncWorkspaceDeleteToBucket,
+  updateWorkspace,
+  writeWorkspaceFile
+} from "./chunk-E72GXBXF.js";
 import {
   BaseApiRoute,
   createSSEResponse,
@@ -96,6 +157,11 @@ import {
   loginSystemUser,
   resolveUserFromToken
 } from "./chunk-ZDH4XI7W.js";
+import {
+  BackendProvider,
+  useBackend,
+  useBackendClient
+} from "./chunk-G3ZOSXUR.js";
 import {
   BackendRegistry,
   ConcurrencyConflictError,
@@ -109,19 +175,6 @@ import {
   RemoteExecutor,
   createEmptyContract
 } from "./chunk-5E6JRFUH.js";
-import {
-  AuditLogger,
-  ControlPlaneManager,
-  DatabaseClusterManager,
-  detectDatabaseEngine,
-  getSystemDatabaseUrls,
-  resolveSystemDatabaseClusterNodes
-} from "./chunk-RCCQ7IRM.js";
-import {
-  BackendProvider,
-  useBackend,
-  useBackendClient
-} from "./chunk-G3ZOSXUR.js";
 import {
   BackendClient,
   BackendResolver,
@@ -134,66 +187,26 @@ import {
   createBackendClient
 } from "./chunk-NIP22V2G.js";
 import {
-  CompositeBackend,
-  EndpointGenerator,
-  LOCAL_STORAGE_GRAPHS_PREFIX,
-  NodeGraphPersistenceService,
-  createBackend,
-  createCompositeService,
-  createLocalService,
-  createRemoteService,
-  exportGraphAsJsonFile,
-  nodeGraphPersistence,
-  parseGraphJsonFile,
-  validateGraphDocument
-} from "./chunk-R27SHBHK.js";
-import {
-  workspaceGraphService
-} from "./chunk-ZFCEXTNI.js";
-import {
-  BackblazeB2Adapter,
-  BaseStorageAdapter,
-  LocalFSAdapter,
-  S3Adapter,
-  StorageAdapterFactory,
-  SupabaseStorageAdapter,
-  ensureS3DirectoryMarker,
-  isSecretMasked,
-  normalizeBackblazeCredentials,
-  permanentDeleteS3Folder,
-  permanentDeleteS3Object,
-  renameS3Folder,
-  resolveBackblazeEndpoint
-} from "./chunk-J2J24JVC.js";
+  AuditLogger,
+  ControlPlaneManager,
+  DatabaseClusterManager,
+  detectDatabaseEngine,
+  getSystemDatabaseUrls,
+  resolveSystemDatabaseClusterNodes
+} from "./chunk-RCCQ7IRM.js";
 import {
-  b2DeleteFileVersion,
-  b2DeleteFolder,
-  b2ListBuckets as b2ListBuckets2,
-  cleanDbUrl,
-  createWorkspace,
-  deleteWorkspace,
-  deleteWorkspaceFile,
-  deleteWorkspaceFolder,
-  findUserWorkspace,
-  getB2BucketId,
-  getUnifiedDbUrl,
-  getWorkspaceFolderPrefix,
-  getWorkspaceStorageDetails,
-  getWorkspaces,
-  isB2Workspace,
-  listWorkspaceFiles,
-  loadWorkspaceData,
-  queryUnifiedDb,
-  readWorkspaceFile,
-  renameAppInWorkspaceData,
-  resolveWorkspaceConnection,
-  saveWorkspaceData,
-  syncWorkspaceCreateToBucket,
-  syncWorkspaceDataToBucket,
-  syncWorkspaceDeleteToBucket,
-  updateWorkspace,
-  writeWorkspaceFile
-} from "./chunk-E72GXBXF.js";
+  DevelopmentRuntime,
+  DevelopmentServiceDefinition,
+  DevelopmentServiceFacade,
+  GitHubActionsClient,
+  GitHubActionsServiceDefinition,
+  GitHubActionsServiceFacade,
+  WebContainerRuntime,
+  WebContainerServiceDefinition,
+  WebContainerServiceFacade,
+  resolveDevelopmentCommand
+} from "./chunk-OVTXAGL6.js";
+import "./chunk-TY32TUNI.js";
 
 // src/data/BaseDataProvider.ts
 import { SkipoBase } from "@ultrst-armada/kloks/functions";
@@ -4375,6 +4388,9 @@ export {
   DatabaseClusterManager,
   DatabaseServiceDefinition,
   DatabaseServiceFacade,
+  DevelopmentRuntime,
+  DevelopmentServiceDefinition,
+  DevelopmentServiceFacade,
   EndpointGenerator,
   EventBus,
   FrontendSession,
@@ -4382,6 +4398,9 @@ export {
   GRAPHS_ROOT,
   GeminiServiceDefinition,
   GeminiServiceFacade,
+  GitHubActionsClient,
+  GitHubActionsServiceDefinition,
+  GitHubActionsServiceFacade,
   HTTPTransport,
   HealthMonitor,
   IdempotencyManager,
@@ -4420,6 +4439,9 @@ export {
   VercelResourceFetcher,
   WORKSPACE_ASSETS_ROOT,
   WORKSPACE_ROOT,
+  WebContainerRuntime,
+  WebContainerServiceDefinition,
+  WebContainerServiceFacade,
   WebSocketTransport,
   WorkingWorkspaceService,
   WorkspaceCloneSyncEngine,
@@ -4568,6 +4590,7 @@ export {
   renameAppInWorkspaceData,
   renameS3Folder,
   resolveBackblazeEndpoint,
+  resolveDevelopmentCommand,
   resolveDynamicRouteFromDb,
   resolveSystemDatabaseClusterNodes,
   resolveSystemDatabaseUrl,

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

@@ -31,14 +31,15 @@ import {
   krnlWorkspaceGraphServiceFacade,
   krnlWorkspaceServiceDefinition,
   krnlWorkspaceServiceFacade
-} from "./chunk-KYBO7FGP.js";
+} from "./chunk-GQUNN7SA.js";
+import "./chunk-DBZVGMJ7.js";
 import "./chunk-VDROUXFT.js";
+import "./chunk-J2J24JVC.js";
 import "./chunk-4QEMALXF.js";
 import "./chunk-FZKBTF34.js";
-import "./chunk-ZDH4XI7W.js";
-import "./chunk-ZFCEXTNI.js";
-import "./chunk-J2J24JVC.js";
 import "./chunk-E72GXBXF.js";
+import "./chunk-ZDH4XI7W.js";
+import "./chunk-TY32TUNI.js";
 export {
   AuthServiceDefinition,
   AuthServiceFacade,

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

@@ -11,12 +11,13 @@ import {
   nodeGraphPersistence,
   parseGraphJsonFile,
   validateGraphDocument
-} from "../chunk-R27SHBHK.js";
+} from "../chunk-RBF2OGMC.js";
 import {
   workspaceGraphService
-} from "../chunk-ZFCEXTNI.js";
+} from "../chunk-DBZVGMJ7.js";
 import "../chunk-J2J24JVC.js";
 import "../chunk-E72GXBXF.js";
+import "../chunk-TY32TUNI.js";
 export {
   CompositeBackend,
   EndpointGenerator,

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

@@ -1,11 +1,4 @@
 import "../chunk-LS3HWJBX.js";
-import {
-  authorizeB2,
-  b2DownloadFile,
-  b2ListBuckets,
-  b2ListFileNames,
-  b2UploadFile
-} from "../chunk-4QEMALXF.js";
 import {
   BackblazeB2Adapter,
   BaseStorageAdapter,
@@ -21,6 +14,13 @@ import {
   renameS3Folder,
   resolveBackblazeEndpoint
 } from "../chunk-J2J24JVC.js";
+import {
+  authorizeB2,
+  b2DownloadFile,
+  b2ListBuckets,
+  b2ListFileNames,
+  b2UploadFile
+} from "../chunk-4QEMALXF.js";
 export {
   BackblazeB2Adapter,
   BaseStorageAdapter,

package/packages/backend/kloks.manifest.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://skipo.dev/schemas/kloks-manifest.v1.json",
   "package": "@kloks/backend",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "services": [
     {
       "id": "auth",
@@ -192,6 +192,74 @@
         ]
       },
       "dependencies": []
+    },
+    {
+      "id": "github-actions",
+      "name": "GitHub Actions Execution",
+      "version": "1.0.0",
+      "description": "Authenticated GitHub Actions workflow dispatch, observation, logs, artifacts, cancellation and rerun service.",
+      "backend": {
+        "package": "@ultrst-armada/kloks",
+        "subpath": "development",
+        "export": "GitHubActionsServiceFacade",
+        "facade": "GitHubActionsServiceFacade"
+      },
+      "modes": [
+        "backend",
+        "fullstack"
+      ],
+      "targets": {
+        "backend": [
+          "BackendFacade.services"
+        ]
+      },
+      "dependencies": []
+    },
+    {
+      "id": "web-container",
+      "name": "WebContainer Runtime",
+      "version": "1.1.0",
+      "description": "Canonical browser WebContainer lifecycle, filesystem mounting and arbitrary development command execution.",
+      "backend": {
+        "package": "@ultrst-armada/kloks",
+        "subpath": "development",
+        "export": "WebContainerServiceFacade",
+        "facade": "WebContainerServiceFacade"
+      },
+      "modes": [
+        "fullstack"
+      ],
+      "targets": {
+        "backend": [
+          "App.main-content"
+        ]
+      },
+      "dependencies": []
+    },
+    {
+      "id": "development",
+      "name": "Development & Validation",
+      "version": "1.0.0",
+      "description": "Provider-neutral development execution planning and validation across WebContainer and GitHub Actions.",
+      "backend": {
+        "package": "@ultrst-armada/kloks",
+        "subpath": "development",
+        "export": "DevelopmentServiceFacade",
+        "facade": "DevelopmentServiceFacade"
+      },
+      "modes": [
+        "backend",
+        "fullstack"
+      ],
+      "targets": {
+        "backend": [
+          "BackendFacade.services"
+        ]
+      },
+      "dependencies": [
+        "github-actions",
+        "web-container"
+      ]
     }
   ]
 }

package/packages/backend/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@kloks/backend",
-  "version": "1.0.0",
-  "description": "Kloks Backend Services \u2014 Auth, Storage, Workspace, Control Plane, API, Connectivity & Execution built on KrnlTS",
+  "version": "1.1.0",
+  "description": "Kloks Backend Services — Auth, Storage, Workspace, Control Plane, API, Connectivity & Execution built on KrnlTS",
   "type": "module",
   "private": false,
   "publishConfig": {
@@ -67,16 +67,22 @@
       "import": "./dist/krnl-services.js",
       "types": "./dist/krnl-services.d.ts",
       "default": "./dist/krnl-services.js"
+    },
+    "./development": {
+      "import": "./dist/development/index.js",
+      "types": "./dist/development/index.d.ts",
+      "default": "./dist/development/index.js"
     }
   },
   "scripts": {
-    "build": "tsup src/index.ts src/krnl-services.ts src/services/index.ts src/auth/index.ts src/storage/index.ts src/workspace/index.ts src/control-plane/index.ts src/api/index.ts src/connectivity/index.ts src/client/index.ts src/srkl/index.ts --format esm --dts --clean --external @kloks/functions --external react --external @kloks/state-graph --external @neondatabase/serverless --external @supabase/supabase-js --external @aws-sdk/client-s3 --external @aws-sdk/lib-storage --external bcryptjs --external better-sqlite3 --external zod --external ws",
+    "build": "tsup src/index.ts src/krnl-services.ts src/services/index.ts src/auth/index.ts src/storage/index.ts src/workspace/index.ts src/control-plane/index.ts src/api/index.ts src/connectivity/index.ts src/client/index.ts src/srkl/index.ts src/development/index.ts --format esm --dts --clean --external @kloks/functions --external react --external @kloks/state-graph --external @neondatabase/serverless --external @supabase/supabase-js --external @aws-sdk/client-s3 --external @aws-sdk/lib-storage --external bcryptjs --external better-sqlite3 --external zod --external ws --external @webcontainer/api",
     "typecheck": "tsc --noEmit",
     "clean": "rm -rf dist"
   },
   "dependencies": {
     "@kloks/functions": "workspace:*",
-    "@kloks/state-graph": "workspace:*"
+    "@kloks/state-graph": "workspace:*",
+    "@webcontainer/api": "^1.6.4"
   },
   "peerDependencies": {
     "better-sqlite3": "^11.0.0",