@ultrst-armada/kloks 1.4.7 → 1.5.1

package/.krusbl-release-attestation.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ultrst-armada/kloks",
-  "version": "1.4.7",
+  "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-ZO3PZGNQ.js → chunk-E72GXBXF.js}

@@ -1,14 +1,3 @@
-// src/workspace/WorkspaceCanonical.ts
-function formatCanonicalWorkspaceFolderName(appName, userName, workspaceName) {
-  const safeApp = appName.replace(/[^a-zA-Z0-9]/g, "_").toLowerCase();
-  const safeUser = userName.replace(/[^a-zA-Z0-9]/g, "_").toLowerCase();
-  const safeWs = workspaceName.replace(/[^a-zA-Z0-9]/g, "_").toLowerCase();
-  return `ultrst_${safeApp}_${safeUser}_${safeWs}`;
-}
-function sanitizeWorkspaceName(name) {
-  return name.replace(/[^a-zA-Z0-9-_\s]/g, "").trim();
-}
-
 // src/core/unifiedDb.ts
 var neon;
 function cleanDbUrl(url) {
@@ -729,8 +718,6 @@ async function getWorkspaceStorageDetails(workspaceId, env) {
 }
 
 export {
-  formatCanonicalWorkspaceFolderName,
-  sanitizeWorkspaceName,
   cleanDbUrl,
   getUnifiedDbUrl,
   queryUnifiedDb,

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

@@ -0,0 +1,15 @@
+// src/workspace/WorkspaceCanonical.ts
+function formatCanonicalWorkspaceFolderName(appName, userName, workspaceName) {
+  const safeApp = appName.replace(/[^a-zA-Z0-9]/g, "_").toLowerCase();
+  const safeUser = userName.replace(/[^a-zA-Z0-9]/g, "_").toLowerCase();
+  const safeWs = workspaceName.replace(/[^a-zA-Z0-9]/g, "_").toLowerCase();
+  return `ultrst_${safeApp}_${safeUser}_${safeWs}`;
+}
+function sanitizeWorkspaceName(name) {
+  return name.replace(/[^a-zA-Z0-9-_\s]/g, "").trim();
+}
+
+export {
+  formatCanonicalWorkspaceFolderName,
+  sanitizeWorkspaceName
+};

package/packages/backend/dist/{chunk-DULUHQ5S.js → chunk-GPXV4GBD.js}

@@ -12,7 +12,7 @@ import {
   readWorkspaceFile,
   updateWorkspace,
   writeWorkspaceFile
-} from "./chunk-ZO3PZGNQ.js";
+} from "./chunk-E72GXBXF.js";
 
 // src/workspace/WorkspaceFS.ts
 import { SkipoBase } from "@ultrst-armada/kloks/functions";

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

@@ -1,3 +1,6 @@
+import {
+  workspaceGraphService
+} from "./chunk-DBZVGMJ7.js";
 import {
   getSrklAccounts,
   srklListBackblazeBuckets
@@ -8,16 +11,18 @@ import {
 import {
   b2ListBuckets
 } from "./chunk-4QEMALXF.js";
+import {
+  formatCanonicalWorkspaceFolderName,
+  sanitizeWorkspaceName
+} from "./chunk-FZKBTF34.js";
 import {
   createWorkspace,
   deleteWorkspace,
   findUserWorkspace,
-  formatCanonicalWorkspaceFolderName,
   getWorkspaces,
   queryUnifiedDb,
-  sanitizeWorkspaceName,
   updateWorkspace
-} from "./chunk-ZO3PZGNQ.js";
+} from "./chunk-E72GXBXF.js";
 import {
   RateLimiter,
   SessionManager,
@@ -332,6 +337,64 @@ var SrklServiceFacade = {
 };
 var krnlSrklServiceDefinition = SrklServiceDefinition;
 var krnlSrklServiceFacade = SrklServiceFacade;
+var WorkspaceGraphServiceDefinition = createServiceDefinition({
+  id: "kloks.backend.workspaceGraph",
+  name: "WorkspaceGraphService",
+  version: "1.0.0",
+  operations: {
+    listGraphs: {
+      id: "WorkspaceGraphService.listGraphs",
+      name: "listGraphs",
+      handler: async (input) => workspaceGraphService.listGraphs(input.userId, input.workspaceId)
+    },
+    createGraph: {
+      id: "WorkspaceGraphService.createGraph",
+      name: "createGraph",
+      handler: async (input) => workspaceGraphService.createGraph(input.userId, input.workspaceId, { name: input.name })
+    },
+    getGraph: {
+      id: "WorkspaceGraphService.getGraph",
+      name: "getGraph",
+      handler: async (input) => workspaceGraphService.getGraph(input.userId, input.workspaceId, input.slug)
+    },
+    saveGraph: {
+      id: "WorkspaceGraphService.saveGraph",
+      name: "saveGraph",
+      handler: async (input) => workspaceGraphService.saveGraph(input.userId, input.workspaceId, input.slug, input)
+    },
+    deleteGraph: {
+      id: "WorkspaceGraphService.deleteGraph",
+      name: "deleteGraph",
+      handler: async (input) => workspaceGraphService.deleteGraph(input.userId, input.workspaceId, input.slug)
+    },
+    duplicateGraph: {
+      id: "WorkspaceGraphService.duplicateGraph",
+      name: "duplicateGraph",
+      handler: async (input) => workspaceGraphService.duplicateGraph(input.userId, input.workspaceId, input.slug, input.newName)
+    },
+    clearGraph: {
+      id: "WorkspaceGraphService.clearGraph",
+      name: "clearGraph",
+      handler: async (input) => workspaceGraphService.clearGraph(input.userId, input.workspaceId, input.slug)
+    }
+  }
+});
+var workspaceGraphServiceInstance = createService(WorkspaceGraphServiceDefinition);
+var WorkspaceGraphServiceFacade = {
+  id: WorkspaceGraphServiceDefinition.id,
+  name: WorkspaceGraphServiceDefinition.name,
+  version: WorkspaceGraphServiceDefinition.version,
+  runtime: "server",
+  deployment: "local",
+  definition: WorkspaceGraphServiceDefinition,
+  createInstance: () => createService(WorkspaceGraphServiceDefinition),
+  execute: async (op, input) => {
+    await workspaceGraphServiceInstance.start();
+    return workspaceGraphServiceInstance.call(op, input);
+  }
+};
+var krnlWorkspaceGraphServiceDefinition = WorkspaceGraphServiceDefinition;
+var krnlWorkspaceGraphServiceFacade = WorkspaceGraphServiceFacade;
 
 export {
   AuthServiceDefinition,
@@ -361,5 +424,9 @@ export {
   SrklServiceDefinition,
   SrklServiceFacade,
   krnlSrklServiceDefinition,
-  krnlSrklServiceFacade
+  krnlSrklServiceFacade,
+  WorkspaceGraphServiceDefinition,
+  WorkspaceGraphServiceFacade,
+  krnlWorkspaceGraphServiceDefinition,
+  krnlWorkspaceGraphServiceFacade
 };

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/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

@@ -10,9 +10,10 @@ export { A as AuthContext, B as BackendClient, a as BackendClientOptions, b as B
 export { BackendContract, BackendRegistry, CallbackDefinition, ConcurrencyConflictError, ConcurrencyManager, DomainContract, EventDefinition, HealthMonitor, IdempotencyManager, InProcessExecutor, JobDefinition, JobHandler, JobScheduler, LoadBalancer, LockManager, OperationDefinition, RemoteExecutor, RemoteExecutorOptions, createEmptyContract } from './connectivity/index.js';
 export { BackendClientInstance, BackendProvider, BackendProviderProps, useBackend, useBackendClient } from './client/index.js';
 export { AdaptedStorageConnection, AppAccountManifest, AppServiceDeclaration, CANONICAL_SRKL_URL, CredentialRegistryMap, EcosystemAccount, EcosystemAccountsRequest, EcosystemAccountsResponse, EcosystemServiceCategory, KeyMaterial, ServiceAccountEntry, SrklClient, SrklClientOptions, SrklCredentialRegistry, SrklEcosystemQueryOptions, SrklEcosystemResponse, SrklServiceAccount, SrklVaultAccessClient, SrklVaultAccessResponse, UseSrklServicesOptions, UseSrklServicesResult, VaultAccessClientOptions, createSrklClient, decryptVaultBufferInBrowser, getPrimarySrklDeploymentUrl, getSrklAccounts, globalCredentialRegistry, hexToBytes, srklListBackblazeBuckets, srklService, syncSrklAccounts, useSrklServices } from './srkl/index.js';
-export { CompositeBackend, EndpointGenerator, GeneratedEndpointSummary, LOCAL_STORAGE_GRAPHS_PREFIX, LocalService, NodeGraphPersistenceService, NodeGraphValidationResult, RemoteServiceProxy, SaveGraphOptions, UniversalAppEntity, UniversalGraphEdge, UniversalGraphNode, UniversalNodeGraphDocument, UniversalStorageConnection, createBackend, createCompositeService, createLocalService, createRemoteService, exportGraphAsJsonFile, nodeGraphPersistence, parseGraphJsonFile, validateGraphDocument } from './services/index.js';
+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, WorkspaceServiceDefinition, WorkspaceServiceFacade, krnlAuthServiceDefinition, krnlAuthServiceFacade, krnlControlPlaneServiceDefinition, krnlControlPlaneServiceFacade, krnlDatabaseServiceDefinition, krnlDatabaseServiceFacade, krnlGeminiServiceDefinition, krnlGeminiServiceFacade, krnlSrklServiceDefinition, krnlSrklServiceFacade, krnlStorageServiceDefinition, krnlStorageServiceFacade, krnlWorkspaceServiceDefinition, krnlWorkspaceServiceFacade } from './krnl-services.js';
+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,
@@ -27,7 +41,7 @@ import {
   setWorkingWorkspaceConfig,
   syncWorkspace,
   workingWorkspaceService
-} from "./chunk-DULUHQ5S.js";
+} from "./chunk-GPXV4GBD.js";
 import {
   AuthServiceDefinition,
   AuthServiceFacade,
@@ -41,6 +55,8 @@ import {
   SrklServiceFacade,
   StorageServiceDefinition,
   StorageServiceFacade,
+  WorkspaceGraphServiceDefinition,
+  WorkspaceGraphServiceFacade,
   WorkspaceServiceDefinition,
   WorkspaceServiceFacade,
   krnlAuthServiceDefinition,
@@ -55,9 +71,14 @@ import {
   krnlSrklServiceFacade,
   krnlStorageServiceDefinition,
   krnlStorageServiceFacade,
+  krnlWorkspaceGraphServiceDefinition,
+  krnlWorkspaceGraphServiceFacade,
   krnlWorkspaceServiceDefinition,
   krnlWorkspaceServiceFacade
-} from "./chunk-ZRYACED2.js";
+} from "./chunk-GQUNN7SA.js";
+import {
+  workspaceGraphService
+} from "./chunk-DBZVGMJ7.js";
 import {
   getPrimarySrklDeploymentUrl,
   getSrklAccounts,
@@ -85,6 +106,10 @@ import {
   b2ListFileNames,
   b2UploadFile
 } from "./chunk-4QEMALXF.js";
+import {
+  formatCanonicalWorkspaceFolderName,
+  sanitizeWorkspaceName
+} from "./chunk-FZKBTF34.js";
 import {
   b2DeleteFileVersion,
   b2DeleteFolder,
@@ -95,7 +120,6 @@ import {
   deleteWorkspaceFile,
   deleteWorkspaceFolder,
   findUserWorkspace,
-  formatCanonicalWorkspaceFolderName,
   getB2BucketId,
   getUnifiedDbUrl,
   getWorkspaceFolderPrefix,
@@ -108,14 +132,13 @@ import {
   readWorkspaceFile,
   renameAppInWorkspaceData,
   resolveWorkspaceConnection,
-  sanitizeWorkspaceName,
   saveWorkspaceData,
   syncWorkspaceCreateToBucket,
   syncWorkspaceDataToBucket,
   syncWorkspaceDeleteToBucket,
   updateWorkspace,
   writeWorkspaceFile
-} from "./chunk-ZO3PZGNQ.js";
+} from "./chunk-E72GXBXF.js";
 import {
   BaseApiRoute,
   createSSEResponse,
@@ -172,19 +195,17 @@ import {
   resolveSystemDatabaseClusterNodes
 } from "./chunk-RCCQ7IRM.js";
 import {
-  CompositeBackend,
-  EndpointGenerator,
-  LOCAL_STORAGE_GRAPHS_PREFIX,
-  NodeGraphPersistenceService,
-  createBackend,
-  createCompositeService,
-  createLocalService,
-  createRemoteService,
-  exportGraphAsJsonFile,
-  nodeGraphPersistence,
-  parseGraphJsonFile,
-  validateGraphDocument
-} from "./chunk-7B24ZWB3.js";
+  DevelopmentRuntime,
+  DevelopmentServiceDefinition,
+  DevelopmentServiceFacade,
+  GitHubActionsClient,
+  GitHubActionsServiceDefinition,
+  GitHubActionsServiceFacade,
+  WebContainerRuntime,
+  WebContainerServiceDefinition,
+  WebContainerServiceFacade,
+  resolveDevelopmentCommand
+} from "./chunk-OVTXAGL6.js";
 import "./chunk-TY32TUNI.js";
 
 // src/data/BaseDataProvider.ts
@@ -4367,6 +4388,9 @@ export {
   DatabaseClusterManager,
   DatabaseServiceDefinition,
   DatabaseServiceFacade,
+  DevelopmentRuntime,
+  DevelopmentServiceDefinition,
+  DevelopmentServiceFacade,
   EndpointGenerator,
   EventBus,
   FrontendSession,
@@ -4374,6 +4398,9 @@ export {
   GRAPHS_ROOT,
   GeminiServiceDefinition,
   GeminiServiceFacade,
+  GitHubActionsClient,
+  GitHubActionsServiceDefinition,
+  GitHubActionsServiceFacade,
   HTTPTransport,
   HealthMonitor,
   IdempotencyManager,
@@ -4412,10 +4439,15 @@ export {
   VercelResourceFetcher,
   WORKSPACE_ASSETS_ROOT,
   WORKSPACE_ROOT,
+  WebContainerRuntime,
+  WebContainerServiceDefinition,
+  WebContainerServiceFacade,
   WebSocketTransport,
   WorkingWorkspaceService,
   WorkspaceCloneSyncEngine,
   WorkspaceFS,
+  WorkspaceGraphServiceDefinition,
+  WorkspaceGraphServiceFacade,
   WorkspaceServiceDefinition,
   WorkspaceServiceFacade,
   authorizeB2,
@@ -4527,6 +4559,8 @@ export {
   krnlSrklServiceFacade,
   krnlStorageServiceDefinition,
   krnlStorageServiceFacade,
+  krnlWorkspaceGraphServiceDefinition,
+  krnlWorkspaceGraphServiceFacade,
   krnlWorkspaceServiceDefinition,
   krnlWorkspaceServiceFacade,
   listAllGraphPackages,
@@ -4556,6 +4590,7 @@ export {
   renameAppInWorkspaceData,
   renameS3Folder,
   resolveBackblazeEndpoint,
+  resolveDevelopmentCommand,
   resolveDynamicRouteFromDb,
   resolveSystemDatabaseClusterNodes,
   resolveSystemDatabaseUrl,
@@ -4599,5 +4634,6 @@ export {
   withAuth,
   withCors,
   workingWorkspaceService,
+  workspaceGraphService,
   writeWorkspaceFile
 };

package/packages/backend/dist/krnl-services.d.ts

@@ -155,5 +155,27 @@ declare const krnlSrklServiceFacade: {
     createInstance: () => _ultrst_armada_krnl.ServiceInstance<Record<string, unknown>, Record<string, unknown>>;
     execute: <TIn = unknown, TOut = unknown>(op: string, input?: TIn) => Promise<TOut>;
 };
+declare const WorkspaceGraphServiceDefinition: ServiceDefinition;
+declare const WorkspaceGraphServiceFacade: {
+    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>;
+};
+declare const krnlWorkspaceGraphServiceDefinition: ServiceDefinition<Record<string, unknown>, Record<string, unknown>>;
+declare const krnlWorkspaceGraphServiceFacade: {
+    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 { AuthServiceDefinition, AuthServiceFacade, ControlPlaneServiceDefinition, ControlPlaneServiceFacade, DatabaseServiceDefinition, DatabaseServiceFacade, GeminiServiceDefinition, GeminiServiceFacade, SrklServiceDefinition, SrklServiceFacade, StorageServiceDefinition, StorageServiceFacade, WorkspaceServiceDefinition, WorkspaceServiceFacade, krnlAuthServiceDefinition, krnlAuthServiceFacade, krnlControlPlaneServiceDefinition, krnlControlPlaneServiceFacade, krnlDatabaseServiceDefinition, krnlDatabaseServiceFacade, krnlGeminiServiceDefinition, krnlGeminiServiceFacade, krnlSrklServiceDefinition, krnlSrklServiceFacade, krnlStorageServiceDefinition, krnlStorageServiceFacade, krnlWorkspaceServiceDefinition, krnlWorkspaceServiceFacade };
+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 };

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

@@ -11,6 +11,8 @@ import {
   SrklServiceFacade,
   StorageServiceDefinition,
   StorageServiceFacade,
+  WorkspaceGraphServiceDefinition,
+  WorkspaceGraphServiceFacade,
   WorkspaceServiceDefinition,
   WorkspaceServiceFacade,
   krnlAuthServiceDefinition,
@@ -25,13 +27,17 @@ import {
   krnlSrklServiceFacade,
   krnlStorageServiceDefinition,
   krnlStorageServiceFacade,
+  krnlWorkspaceGraphServiceDefinition,
+  krnlWorkspaceGraphServiceFacade,
   krnlWorkspaceServiceDefinition,
   krnlWorkspaceServiceFacade
-} from "./chunk-ZRYACED2.js";
+} from "./chunk-GQUNN7SA.js";
+import "./chunk-DBZVGMJ7.js";
 import "./chunk-VDROUXFT.js";
 import "./chunk-J2J24JVC.js";
 import "./chunk-4QEMALXF.js";
-import "./chunk-ZO3PZGNQ.js";
+import "./chunk-FZKBTF34.js";
+import "./chunk-E72GXBXF.js";
 import "./chunk-ZDH4XI7W.js";
 import "./chunk-TY32TUNI.js";
 export {
@@ -47,6 +53,8 @@ export {
   SrklServiceFacade,
   StorageServiceDefinition,
   StorageServiceFacade,
+  WorkspaceGraphServiceDefinition,
+  WorkspaceGraphServiceFacade,
   WorkspaceServiceDefinition,
   WorkspaceServiceFacade,
   krnlAuthServiceDefinition,
@@ -61,6 +69,8 @@ export {
   krnlSrklServiceFacade,
   krnlStorageServiceDefinition,
   krnlStorageServiceFacade,
+  krnlWorkspaceGraphServiceDefinition,
+  krnlWorkspaceGraphServiceFacade,
   krnlWorkspaceServiceDefinition,
   krnlWorkspaceServiceFacade
 };

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

@@ -228,4 +228,67 @@ declare class NodeGraphPersistenceService {
 }
 declare const nodeGraphPersistence: NodeGraphPersistenceService;
 
-export { CompositeBackend, EndpointGenerator, type GeneratedEndpointSummary, LOCAL_STORAGE_GRAPHS_PREFIX, type LocalService, NodeGraphPersistenceService, type NodeGraphValidationResult, type RemoteServiceProxy, type SaveGraphOptions, type UniversalAppEntity, type UniversalGraphEdge, type UniversalGraphNode, type UniversalNodeGraphDocument, type UniversalStorageConnection, createBackend, createCompositeService, createLocalService, createRemoteService, exportGraphAsJsonFile, nodeGraphPersistence, parseGraphJsonFile, validateGraphDocument };
+/**
+ * @file workspaceGraphService.ts
+ * @description Universal workspace-scoped graph persistence service.
+ *
+ * This service owns graph documents and storage only. It does not know about
+ * BRWLR, Playwright, ZX, node factories, or any application-specific node type.
+ */
+
+interface WorkspaceGraphDocument extends UniversalNodeGraphDocument {
+    workspaceId: string;
+    graphId: string;
+    graphSlug: string;
+}
+interface WorkspaceGraphSummary {
+    id: string;
+    name: string;
+    slug: string;
+    createdAt: string;
+    updatedAt: string;
+    nodeCount: number;
+}
+declare const workspaceGraphService: {
+    listGraphs(userId: string, workspaceId: string): Promise<{
+        success: true;
+        graphs: WorkspaceGraphSummary[];
+    }>;
+    createGraph(userId: string, workspaceId: string, input: {
+        name?: string;
+    }): Promise<{
+        success: true;
+        graph: WorkspaceGraphDocument;
+        graphs: any;
+    }>;
+    getGraph(userId: string, workspaceId: string, slug: string): Promise<{
+        success: true;
+        graph: WorkspaceGraphDocument;
+    }>;
+    saveGraph(userId: string, workspaceId: string, slug: string, patch: {
+        nodes?: UniversalGraphNode[];
+        edges?: UniversalGraphEdge[];
+        name?: string;
+    }): Promise<{
+        success: true;
+        graph: WorkspaceGraphDocument;
+    }>;
+    deleteGraph(userId: string, workspaceId: string, slug: string): Promise<{
+        success: true;
+        deletedSlug: string;
+        graphs: any;
+    }>;
+    duplicateGraph(userId: string, workspaceId: string, slug: string, newName?: string): Promise<{
+        success: true;
+        graph: WorkspaceGraphDocument;
+        graphs: any;
+    }>;
+    clearGraph(userId: string, workspaceId: string, slug: string): Promise<any>;
+    getGraphDocument(userId: string, workspaceId: string, slug: string): Promise<any>;
+    saveGraphDocument(userId: string, workspaceId: string, document: WorkspaceGraphDocument): Promise<{
+        success: true;
+        graph: WorkspaceGraphDocument;
+    }>;
+};
+
+export { CompositeBackend, EndpointGenerator, type GeneratedEndpointSummary, LOCAL_STORAGE_GRAPHS_PREFIX, type LocalService, NodeGraphPersistenceService, type NodeGraphValidationResult, type RemoteServiceProxy, type SaveGraphOptions, type UniversalAppEntity, type UniversalGraphEdge, type UniversalGraphNode, type UniversalNodeGraphDocument, type UniversalStorageConnection, type WorkspaceGraphDocument, type WorkspaceGraphSummary, createBackend, createCompositeService, createLocalService, createRemoteService, exportGraphAsJsonFile, nodeGraphPersistence, parseGraphJsonFile, validateGraphDocument, workspaceGraphService };

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

@@ -11,7 +11,12 @@ import {
   nodeGraphPersistence,
   parseGraphJsonFile,
   validateGraphDocument
-} from "../chunk-7B24ZWB3.js";
+} from "../chunk-RBF2OGMC.js";
+import {
+  workspaceGraphService
+} from "../chunk-DBZVGMJ7.js";
+import "../chunk-J2J24JVC.js";
+import "../chunk-E72GXBXF.js";
 import "../chunk-TY32TUNI.js";
 export {
   CompositeBackend,
@@ -25,5 +30,6 @@ export {
   exportGraphAsJsonFile,
   nodeGraphPersistence,
   parseGraphJsonFile,
-  validateGraphDocument
+  validateGraphDocument,
+  workspaceGraphService
 };

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

@@ -6,11 +6,12 @@ import {
   WorkspaceFS,
   remoteWorkspaceService,
   workingWorkspaceService
-} from "../chunk-DULUHQ5S.js";
+} from "../chunk-GPXV4GBD.js";
 import {
   formatCanonicalWorkspaceFolderName,
   sanitizeWorkspaceName
-} from "../chunk-ZO3PZGNQ.js";
+} from "../chunk-FZKBTF34.js";
+import "../chunk-E72GXBXF.js";
 export {
   RemoteWorkspaceService,
   SyncEngine,

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",