@ultrst-armada/kloks 1.4.8 → 1.5.2

package/.krusbl-release-attestation.json

@@ -1,8 +1,8 @@
 {
   "schema": 1,
   "packageName": "@ultrst-armada/kloks",
-  "version": "1.4.8",
-  "sourceCommit": "6ab0d5dfede2344d9dd35ce366b67ac44b808401",
+  "version": "1.5.2",
+  "sourceCommit": "07f2e1a49da642bbfd42cd79422306c93195493f",
   "releaseWorkflow": "npm Release",
-  "workflowRunId": "39557640590"
+  "workflowRunId": "39969373482"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ultrst-armada/kloks",
-  "version": "1.4.8",
+  "version": "1.5.2",
   "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-3Z7EUZWE.js

@@ -0,0 +1,383 @@
+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);
+  }
+};
+
+// src/development/codeValidationService.ts
+var COMMANDS2 = {
+  syntax: { command: "pnpm", args: ["exec", "tsc", "--noEmit"] },
+  lint: { command: "pnpm", args: ["run", "lint", "--if-present"] },
+  test: { command: "pnpm", args: ["run", "test", "--if-present"] },
+  build: { command: "pnpm", args: ["run", "build", "--if-present"] },
+  krnl: { command: "pnpm", args: ["exec", "krnl", "validate"] },
+  frnl: { command: "pnpm", args: ["exec", "frnl", "validate"] }
+};
+var DEFAULT_LAYERS = ["syntax", "lint", "krnl", "frnl"];
+var commandText = (command, args) => [command, ...args].join(" ");
+var CodeValidationRuntime = class {
+  constructor(runtime3 = new WebContainerRuntime()) {
+    this.runtime = runtime3;
+  }
+  runtime;
+  async validate(input = {}) {
+    if (input.files) await this.runtime.mount(input.files);
+    const diagnostics = [];
+    if (input.install) {
+      const installed = await this.runtime.runCommand("pnpm", ["install", "--no-frozen-lockfile"], input.cwd, input.env);
+      diagnostics.push({ layer: "lint", ok: installed.exitCode === 0, exitCode: installed.exitCode, output: installed.output, command: "pnpm install --no-frozen-lockfile" });
+      if (installed.exitCode !== 0) return { ok: false, diagnostics, failedLayers: ["lint"] };
+    }
+    const layers = input.layers?.length ? input.layers : DEFAULT_LAYERS;
+    for (const layer of layers) {
+      if (layer === "law-l9") {
+        diagnostics.push(await this.validateLawL9(input.cwd, input.maxLines ?? 200));
+        continue;
+      }
+      const spec = COMMANDS2[layer];
+      const result = await this.runtime.runCommand(spec.command, spec.args, input.cwd, input.env);
+      diagnostics.push({ layer, ok: result.exitCode === 0, exitCode: result.exitCode, output: result.output, command: commandText(spec.command, spec.args) });
+      if (result.exitCode !== 0) break;
+    }
+    return { ok: diagnostics.every((item) => item.ok), diagnostics, failedLayers: diagnostics.filter((item) => !item.ok).map((item) => item.layer) };
+  }
+  async validateLawL9(cwd = ".", maxLines = 200) {
+    const script = `python3 -c 'import os,sys; bad=[]; root="src"; [bad.append(os.path.join(r,f)+": "+str(len(open(os.path.join(r,f),encoding="utf-8",errors="ignore").readlines()))+" lines") for r,_,fs in os.walk(root) for f in fs if f.endswith((".ts",".tsx",".js",".jsx")) and not f.endswith(".d.ts") and len(open(os.path.join(r,f),encoding="utf-8",errors="ignore").readlines())>200]; print("\\n".join(bad)); sys.exit(1 if bad else 0)'`;
+    const result = await this.runtime.runCommand("sh", ["-lc", script], cwd);
+    return { layer: "law-l9", ok: result.exitCode === 0, exitCode: result.exitCode, output: result.output, command: script };
+  }
+};
+var runtime2 = new CodeValidationRuntime();
+var CodeValidationServiceDefinition = createServiceDefinition({
+  id: "kloks.backend.codeValidation",
+  name: "CodeValidationService",
+  version: "1.0.0",
+  operations: { validate: { id: "CodeValidationService.validate", name: "validate", handler: async (input) => runtime2.validate(input) } }
+});
+var CodeValidationServiceFacade = {
+  id: CodeValidationServiceDefinition.id,
+  name: CodeValidationServiceDefinition.name,
+  version: CodeValidationServiceDefinition.version,
+  runtime: "client",
+  deployment: "local",
+  definition: CodeValidationServiceDefinition,
+  createInstance: () => createService(CodeValidationServiceDefinition),
+  execute: async (op, input) => {
+    const instance = createService(CodeValidationServiceDefinition);
+    await instance.start();
+    return instance.call(op, input);
+  }
+};
+
+// src/development/codeDiagnosticsService.ts
+var CodeDiagnosticsService = class {
+  constructor(runtime3 = new WebContainerRuntime()) {
+    this.runtime = runtime3;
+  }
+  runtime;
+  async diagnostics(input = {}) {
+    const args = ["exec", "tsc", "--noEmit", "--pretty", "false"];
+    if (input.file) args.push(input.file);
+    const result = await this.runtime.runCommand("pnpm", args, input.cwd);
+    return { ok: result.exitCode === 0, output: result.output, command: ["pnpm", ...args].join(" ") };
+  }
+};
+var codeDiagnosticsService = new CodeDiagnosticsService();
+
+export {
+  GitHubActionsClient,
+  GitHubActionsServiceDefinition,
+  GitHubActionsServiceFacade,
+  WebContainerRuntime,
+  WebContainerServiceDefinition,
+  WebContainerServiceFacade,
+  resolveDevelopmentCommand,
+  DevelopmentServiceDefinition,
+  DevelopmentRuntime,
+  DevelopmentServiceFacade,
+  CodeValidationRuntime,
+  CodeValidationServiceDefinition,
+  CodeValidationServiceFacade,
+  CodeDiagnosticsService,
+  codeDiagnosticsService
+};

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