@ultrst-armada/kloks 1.18.0 → 1.19.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1,8 +1,8 @@
1
1
  {
2
2
  "schema": 1,
3
3
  "packageName": "@ultrst-armada/kloks",
4
- "version": "1.18.0",
5
- "sourceCommit": "68e60d5bca11dc544cc0e3368ec5a4aa948fcab2",
4
+ "version": "1.19.0",
5
+ "sourceCommit": "5af44cb81c5dcd3db7c1118ada75b24d619b3adb",
6
6
  "releaseWorkflow": "npm Release",
7
- "workflowRunId": "40854825295"
7
+ "workflowRunId": "40941286261"
8
8
  }
package/index.d.ts CHANGED
@@ -5,3 +5,4 @@ export * from './packages/services/dist/index.d.ts';
5
5
  export * from './packages/backend/dist/index.d.ts';
6
6
  export * from './packages/orchestrations/dist/index.d.ts';
7
7
  export * from './packages/contracts/dist/index.d.ts';
8
+ export * from './packages/fod/dist/index.d.ts';
package/index.js CHANGED
@@ -5,3 +5,4 @@ export * from './packages/services/dist/index.js';
5
5
  export * from './packages/backend/dist/index.js';
6
6
  export * from './packages/orchestrations/dist/index.js';
7
7
  export * from './packages/contracts/dist/index.js';
8
+ export * from './packages/fod/dist/index';
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@ultrst-armada/kloks",
3
- "version": "1.18.0",
3
+ "version": "1.19.0",
4
4
  "private": false,
5
5
  "publishConfig": {
6
6
  "access": "public",
@@ -144,6 +144,11 @@
144
144
  "types": "./packages/backend/dist/krnl-ai-services.d.ts",
145
145
  "import": "./packages/backend/dist/krnl-ai-services.js",
146
146
  "default": "./packages/backend/dist/krnl-ai-services.js"
147
+ },
148
+ "./fod": {
149
+ "types": "./packages/fod/dist/index.d.ts",
150
+ "import": "./packages/fod/dist/index.js",
151
+ "default": "./packages/fod/dist/index.js"
147
152
  }
148
153
  },
149
154
  "scripts": {
@@ -0,0 +1,155 @@
1
+ import * as _ultrst_armada_krnl from '@ultrst-armada/krnl';
2
+ import { ServiceDefinition } from '@ultrst-armada/krnl';
3
+
4
+ type FodPortDirection = 'input' | 'output';
5
+ type FodNodeCategory = 'host-app' | 'gutts' | 'flow' | 'system';
6
+ interface FodPort {
7
+ id: string;
8
+ name: string;
9
+ direction: FodPortDirection;
10
+ dataType: string;
11
+ required?: boolean;
12
+ description?: string;
13
+ schema?: Record<string, unknown>;
14
+ }
15
+ interface FodNodeDefinition {
16
+ type: string;
17
+ label: string;
18
+ description: string;
19
+ category: FodNodeCategory;
20
+ group: string;
21
+ inputs: FodPort[];
22
+ outputs: FodPort[];
23
+ metadata?: Record<string, unknown>;
24
+ }
25
+ interface FodEndpointDescriptor {
26
+ id: string;
27
+ serviceId: string;
28
+ serviceName: string;
29
+ operationId: string;
30
+ operationName: string;
31
+ description?: string;
32
+ runtime?: string;
33
+ deployment?: string;
34
+ inputSchema?: Record<string, unknown>;
35
+ outputSchema?: Record<string, unknown>;
36
+ invoke: (input: unknown) => Promise<unknown>;
37
+ }
38
+ interface FodFlowNode {
39
+ id: string;
40
+ type: string;
41
+ position: {
42
+ x: number;
43
+ y: number;
44
+ };
45
+ data: Record<string, unknown>;
46
+ }
47
+ interface FodFlowEdge {
48
+ id: string;
49
+ source: string;
50
+ sourceHandle?: string;
51
+ target: string;
52
+ targetHandle?: string;
53
+ }
54
+ interface FodFlow {
55
+ id: string;
56
+ name: string;
57
+ description?: string;
58
+ version: number;
59
+ createdAt: string;
60
+ updatedAt: string;
61
+ nodes: FodFlowNode[];
62
+ edges: FodFlowEdge[];
63
+ viewport?: {
64
+ x: number;
65
+ y: number;
66
+ zoom: number;
67
+ };
68
+ metadata?: Record<string, unknown>;
69
+ }
70
+ interface FodExecutionEvent {
71
+ type: 'flow-started' | 'node-started' | 'node-completed' | 'node-failed' | 'flow-completed';
72
+ timestamp: number;
73
+ flowId: string;
74
+ nodeId?: string;
75
+ data?: unknown;
76
+ }
77
+ interface FodExecutionResult {
78
+ success: boolean;
79
+ flowId: string;
80
+ output: unknown;
81
+ outputs: Record<string, unknown>;
82
+ errors: Array<{
83
+ nodeId?: string;
84
+ message: string;
85
+ }>;
86
+ events: FodExecutionEvent[];
87
+ }
88
+ interface FodRuntimeOptions {
89
+ workspaceId: string;
90
+ workspaceService: any;
91
+ endpoints?: FodEndpointDescriptor[];
92
+ nodes?: FodNodeDefinition[];
93
+ onEvent?: (event: FodExecutionEvent) => void;
94
+ }
95
+
96
+ declare function scanBackendFacade(facade: Record<string, unknown>): FodEndpointDescriptor[];
97
+ declare function endpointToNode(endpoint: FodEndpointDescriptor): FodNodeDefinition;
98
+ declare function scanBackendFacadeToNodes(facade: Record<string, unknown>): {
99
+ endpoints: FodEndpointDescriptor[];
100
+ nodes: FodNodeDefinition[];
101
+ };
102
+
103
+ declare class FodFlowStore {
104
+ private readonly workspaceService;
105
+ constructor(workspaceService: any);
106
+ list(workspaceId: string): Promise<FodFlow[]>;
107
+ get(workspaceId: string, flowId: string): Promise<FodFlow | null>;
108
+ save(workspaceId: string, flow: FodFlow): Promise<FodFlow>;
109
+ delete(workspaceId: string, flowId: string): Promise<boolean>;
110
+ }
111
+
112
+ declare function executeFodFlow(flow: FodFlow, endpoints: Map<string, FodEndpointDescriptor>, onEvent?: (event: FodExecutionEvent) => void): Promise<FodExecutionResult>;
113
+
114
+ declare class FodRuntime {
115
+ private readonly options;
116
+ readonly flowStore: FodFlowStore;
117
+ private endpoints;
118
+ private nodes;
119
+ constructor(options: {
120
+ workspaceId: string;
121
+ workspaceService: any;
122
+ onEvent?: (event: any) => void;
123
+ });
124
+ setEndpoints(endpoints: FodEndpointDescriptor[], nodes?: FodNodeDefinition[]): void;
125
+ getNodeDefinitions(): FodNodeDefinition[];
126
+ getEndpoints(): FodEndpointDescriptor[];
127
+ listFlows(): Promise<FodFlow[]>;
128
+ getFlow(flowId: string): Promise<FodFlow | null>;
129
+ saveFlow(flow: FodFlow): Promise<FodFlow>;
130
+ deleteFlow(flowId: string): Promise<boolean>;
131
+ executeFlow(flowId: string): Promise<FodExecutionResult>;
132
+ }
133
+
134
+ declare function createFodServiceFacade(runtime: FodRuntime): {
135
+ id: string;
136
+ name: string;
137
+ version: string;
138
+ runtime: "server";
139
+ deployment: "local";
140
+ definition: ServiceDefinition<Record<string, unknown>, Record<string, unknown>>;
141
+ createInstance: () => _ultrst_armada_krnl.ServiceInstance<Record<string, unknown>, Record<string, unknown>>;
142
+ execute: <TIn = unknown, TOut = unknown>(op: string, input?: TIn) => Promise<TOut>;
143
+ };
144
+ declare function createFodServiceFacadeForWorkspace(buildRuntime: (workspaceId: string) => FodRuntime): {
145
+ id: string;
146
+ name: string;
147
+ version: string;
148
+ runtime: "server";
149
+ deployment: "local";
150
+ definition: ServiceDefinition<Record<string, unknown>, Record<string, unknown>>;
151
+ createInstance: () => _ultrst_armada_krnl.ServiceInstance<Record<string, unknown>, Record<string, unknown>>;
152
+ execute: <TIn = unknown, TOut = unknown>(op: string, input?: TIn) => Promise<TOut>;
153
+ };
154
+
155
+ export { type FodEndpointDescriptor, type FodExecutionEvent, type FodExecutionResult, type FodFlow, type FodFlowEdge, type FodFlowNode, FodFlowStore, type FodNodeCategory, type FodNodeDefinition, type FodPort, type FodPortDirection, FodRuntime, type FodRuntimeOptions, createFodServiceFacade, createFodServiceFacadeForWorkspace, endpointToNode, executeFodFlow, scanBackendFacade, scanBackendFacadeToNodes };
@@ -0,0 +1,254 @@
1
+ // src/endpointNodeProvider.ts
2
+ function portsFromSchema(schema, direction) {
3
+ if (!schema || schema.type !== "object") {
4
+ return [{ id: direction === "input" ? "input" : "result", name: direction === "input" ? "input" : "result", direction, dataType: String(schema?.type ?? "any") }];
5
+ }
6
+ const properties = schema.properties ?? {};
7
+ const required = new Set(Array.isArray(schema.required) ? schema.required.map(String) : []);
8
+ return Object.entries(properties).map(([id, value]) => ({
9
+ id,
10
+ name: id,
11
+ direction,
12
+ dataType: String(value?.type ?? "any"),
13
+ required: required.has(id),
14
+ description: typeof value?.description === "string" ? value.description : void 0,
15
+ schema: value
16
+ }));
17
+ }
18
+ function scanBackendFacade(facade) {
19
+ const endpoints = [];
20
+ const services = facade.services ?? {};
21
+ for (const [serviceKey, service] of Object.entries(services)) {
22
+ const definition = service?.definition;
23
+ if (!definition?.operations) continue;
24
+ for (const [operationKey, operation] of Object.entries(definition.operations)) {
25
+ if (typeof service.execute !== "function") continue;
26
+ endpoints.push({
27
+ id: String(operation.id ?? `${service.id ?? serviceKey}.${operationKey}`),
28
+ serviceId: String(service.id ?? serviceKey),
29
+ serviceName: String(service.name ?? serviceKey),
30
+ operationId: String(operation.id ?? operationKey),
31
+ operationName: String(operation.name ?? operationKey),
32
+ description: typeof operation.description === "string" ? operation.description : void 0,
33
+ runtime: typeof service.runtime === "string" ? service.runtime : void 0,
34
+ deployment: typeof service.deployment === "string" ? service.deployment : void 0,
35
+ inputSchema: operation.inputSchema,
36
+ outputSchema: operation.outputSchema,
37
+ invoke: (input) => service.execute(operationKey, input)
38
+ });
39
+ }
40
+ }
41
+ return endpoints;
42
+ }
43
+ function endpointToNode(endpoint) {
44
+ return {
45
+ type: `host/${endpoint.id}`,
46
+ label: endpoint.operationName,
47
+ description: endpoint.description ?? endpoint.operationId,
48
+ category: "host-app",
49
+ group: endpoint.serviceName,
50
+ inputs: portsFromSchema(endpoint.inputSchema, "input"),
51
+ outputs: portsFromSchema(endpoint.outputSchema, "output"),
52
+ metadata: {
53
+ endpointId: endpoint.id,
54
+ serviceId: endpoint.serviceId,
55
+ operationId: endpoint.operationId,
56
+ runtime: endpoint.runtime,
57
+ deployment: endpoint.deployment
58
+ }
59
+ };
60
+ }
61
+ function scanBackendFacadeToNodes(facade) {
62
+ const endpoints = scanBackendFacade(facade);
63
+ return { endpoints, nodes: endpoints.map(endpointToNode) };
64
+ }
65
+
66
+ // src/flowStore.ts
67
+ var ROOT = "FOD";
68
+ function pathFor(flowId) {
69
+ const safe = flowId.replace(/[^a-zA-Z0-9._-]/g, "_");
70
+ return `${ROOT}/${safe}.json`;
71
+ }
72
+ var FodFlowStore = class {
73
+ constructor(workspaceService) {
74
+ this.workspaceService = workspaceService;
75
+ }
76
+ workspaceService;
77
+ async list(workspaceId) {
78
+ const entries = await this.workspaceService.listFiles(workspaceId, ROOT);
79
+ const flows = [];
80
+ for (const entry of entries) {
81
+ if (entry.isFolder || !entry.name.endsWith(".json")) continue;
82
+ try {
83
+ const raw = await this.workspaceService.readFile(workspaceId, entry.path);
84
+ flows.push(JSON.parse(typeof raw === "string" ? raw : Buffer.from(raw).toString("utf8")));
85
+ } catch {
86
+ }
87
+ }
88
+ return flows.sort((a, b) => a.name.localeCompare(b.name));
89
+ }
90
+ async get(workspaceId, flowId) {
91
+ try {
92
+ const raw = await this.workspaceService.readFile(workspaceId, pathFor(flowId));
93
+ return JSON.parse(typeof raw === "string" ? raw : Buffer.from(raw).toString("utf8"));
94
+ } catch {
95
+ return null;
96
+ }
97
+ }
98
+ async save(workspaceId, flow) {
99
+ const now = (/* @__PURE__ */ new Date()).toISOString();
100
+ const next = { ...flow, updatedAt: now, version: Math.max(1, flow.version ?? 1) };
101
+ await this.workspaceService.writeFile(workspaceId, pathFor(flow.id), JSON.stringify(next, null, 2));
102
+ return next;
103
+ }
104
+ async delete(workspaceId, flowId) {
105
+ const result = await this.workspaceService.deleteFile(workspaceId, pathFor(flowId));
106
+ return Boolean(result?.success);
107
+ }
108
+ };
109
+
110
+ // src/executor.ts
111
+ async function executeFodFlow(flow, endpoints, onEvent) {
112
+ const events = [];
113
+ const errors = [];
114
+ const emit = (event) => {
115
+ events.push(event);
116
+ onEvent?.(event);
117
+ };
118
+ emit({ type: "flow-started", timestamp: Date.now(), flowId: flow.id });
119
+ const outputs = {};
120
+ const incoming = (nodeId) => flow.edges.filter((edge) => edge.target === nodeId);
121
+ const remaining = new Set(flow.nodes.map((node) => node.id));
122
+ const values = /* @__PURE__ */ new Map();
123
+ while (remaining.size) {
124
+ const ready = flow.nodes.filter((node) => remaining.has(node.id) && incoming(node.id).every((edge) => values.has(`${edge.source}:${edge.sourceHandle ?? "result"}`)));
125
+ if (!ready.length) {
126
+ const unresolved = [...remaining].join(", ");
127
+ const message = `Flow contains an unresolved dependency or cycle: ${unresolved}`;
128
+ errors.push({ message });
129
+ break;
130
+ }
131
+ for (const node of ready) {
132
+ remaining.delete(node.id);
133
+ emit({ type: "node-started", timestamp: Date.now(), flowId: flow.id, nodeId: node.id });
134
+ try {
135
+ const endpointId = String(node.data.endpointId ?? node.data.apiId ?? node.type.replace(/^(host|gutts)\//, ""));
136
+ const endpoint = endpoints.get(endpointId);
137
+ if (!endpoint) throw new Error(`No executable endpoint registered for node '${node.type}'.`);
138
+ const input = {};
139
+ for (const edge of incoming(node.id)) {
140
+ input[String(edge.targetHandle ?? "input")] = values.get(`${edge.source}:${edge.sourceHandle ?? "result"}`);
141
+ }
142
+ const configured = node.data.inputs ?? {};
143
+ Object.assign(input, configured);
144
+ const result = await endpoint.invoke(input);
145
+ outputs[node.id] = result;
146
+ values.set(`${node.id}:result`, result);
147
+ if (result && typeof result === "object") {
148
+ for (const [key, value] of Object.entries(result)) values.set(`${node.id}:${key}`, value);
149
+ }
150
+ emit({ type: "node-completed", timestamp: Date.now(), flowId: flow.id, nodeId: node.id, data: result });
151
+ } catch (error) {
152
+ const message = error instanceof Error ? error.message : String(error);
153
+ errors.push({ nodeId: node.id, message });
154
+ emit({ type: "node-failed", timestamp: Date.now(), flowId: flow.id, nodeId: node.id, data: message });
155
+ break;
156
+ }
157
+ }
158
+ if (errors.length) break;
159
+ }
160
+ const success = errors.length === 0 && remaining.size === 0;
161
+ const last = flow.nodes.at(-1);
162
+ emit({ type: "flow-completed", timestamp: Date.now(), flowId: flow.id, data: { success } });
163
+ return { success, flowId: flow.id, output: last ? outputs[last.id] : void 0, outputs, errors, events };
164
+ }
165
+
166
+ // src/runtime.ts
167
+ var FodRuntime = class {
168
+ constructor(options) {
169
+ this.options = options;
170
+ this.flowStore = new FodFlowStore(options.workspaceService);
171
+ }
172
+ options;
173
+ flowStore;
174
+ endpoints = /* @__PURE__ */ new Map();
175
+ nodes = [];
176
+ setEndpoints(endpoints, nodes = []) {
177
+ this.endpoints = new Map(endpoints.map((endpoint) => [endpoint.id, endpoint]));
178
+ this.nodes = nodes;
179
+ }
180
+ getNodeDefinitions() {
181
+ return [...this.nodes];
182
+ }
183
+ getEndpoints() {
184
+ return [...this.endpoints.values()];
185
+ }
186
+ async listFlows() {
187
+ return this.flowStore.list(this.options.workspaceId);
188
+ }
189
+ async getFlow(flowId) {
190
+ return this.flowStore.get(this.options.workspaceId, flowId);
191
+ }
192
+ async saveFlow(flow) {
193
+ return this.flowStore.save(this.options.workspaceId, flow);
194
+ }
195
+ async deleteFlow(flowId) {
196
+ return this.flowStore.delete(this.options.workspaceId, flowId);
197
+ }
198
+ async executeFlow(flowId) {
199
+ const flow = await this.getFlow(flowId);
200
+ if (!flow) throw new Error(`FOD flow '${flowId}' not found.`);
201
+ return executeFodFlow(flow, this.endpoints, this.options.onEvent);
202
+ }
203
+ };
204
+
205
+ // src/index.ts
206
+ import { createService } from "@ultrst-armada/krnl";
207
+ function createFodServiceFacade(runtime) {
208
+ const definition = {
209
+ id: "kloks.fod",
210
+ name: "FodService",
211
+ version: "1.0.0",
212
+ operations: {
213
+ listFlows: { id: "FodService.listFlows", name: "listFlows", inputSchema: { type: "object", properties: {} }, outputSchema: { type: "array" }, handler: async () => runtime.listFlows() },
214
+ getFlow: { id: "FodService.getFlow", name: "getFlow", inputSchema: { type: "object", properties: { flowId: { type: "string" } }, required: ["flowId"] }, outputSchema: { type: "object" }, handler: async (input) => runtime.getFlow(String(input.flowId)) },
215
+ saveFlow: { id: "FodService.saveFlow", name: "saveFlow", inputSchema: { type: "object" }, outputSchema: { type: "object" }, handler: async (input) => runtime.saveFlow(input.flow) },
216
+ deleteFlow: { id: "FodService.deleteFlow", name: "deleteFlow", inputSchema: { type: "object", properties: { flowId: { type: "string" } }, required: ["flowId"] }, outputSchema: { type: "object" }, handler: async (input) => ({ success: await runtime.deleteFlow(String(input.flowId)) }) },
217
+ executeFlow: { id: "FodService.executeFlow", name: "executeFlow", inputSchema: { type: "object", properties: { flowId: { type: "string" } }, required: ["flowId"] }, outputSchema: { type: "object" }, handler: async (input) => runtime.executeFlow(String(input.flowId)) }
218
+ }
219
+ };
220
+ const service = createService(definition);
221
+ return { id: definition.id, name: definition.name, version: definition.version, runtime: "server", deployment: "local", definition, createInstance: () => createService(definition), execute: async (op, input) => {
222
+ await service.start();
223
+ return service.call(op, input);
224
+ } };
225
+ }
226
+ function createFodServiceFacadeForWorkspace(buildRuntime) {
227
+ const definition = {
228
+ id: "kloks.fod",
229
+ name: "FodService",
230
+ version: "1.0.0",
231
+ operations: {
232
+ listFlows: { id: "FodService.listFlows", name: "listFlows", inputSchema: { type: "object", properties: { workspaceId: { type: "string" } }, required: ["workspaceId"] }, outputSchema: { type: "array" }, handler: async (input) => buildRuntime(String(input.workspaceId)).listFlows() },
233
+ getFlow: { id: "FodService.getFlow", name: "getFlow", inputSchema: { type: "object", properties: { workspaceId: { type: "string" }, flowId: { type: "string" } }, required: ["workspaceId", "flowId"] }, outputSchema: { type: "object" }, handler: async (input) => buildRuntime(String(input.workspaceId)).getFlow(String(input.flowId)) },
234
+ saveFlow: { id: "FodService.saveFlow", name: "saveFlow", inputSchema: { type: "object", properties: { workspaceId: { type: "string" }, flow: { type: "object" } }, required: ["workspaceId", "flow"] }, outputSchema: { type: "object" }, handler: async (input) => buildRuntime(String(input.workspaceId)).saveFlow(input.flow) },
235
+ deleteFlow: { id: "FodService.deleteFlow", name: "deleteFlow", inputSchema: { type: "object", properties: { workspaceId: { type: "string" }, flowId: { type: "string" } }, required: ["workspaceId", "flowId"] }, outputSchema: { type: "object" }, handler: async (input) => ({ success: await buildRuntime(String(input.workspaceId)).deleteFlow(String(input.flowId)) }) },
236
+ executeFlow: { id: "FodService.executeFlow", name: "executeFlow", inputSchema: { type: "object", properties: { workspaceId: { type: "string" }, flowId: { type: "string" } }, required: ["workspaceId", "flowId"] }, outputSchema: { type: "object" }, handler: async (input) => buildRuntime(String(input.workspaceId)).executeFlow(String(input.flowId)) }
237
+ }
238
+ };
239
+ const service = createService(definition);
240
+ return { id: definition.id, name: definition.name, version: definition.version, runtime: "server", deployment: "local", definition, createInstance: () => createService(definition), execute: async (op, input) => {
241
+ await service.start();
242
+ return service.call(op, input);
243
+ } };
244
+ }
245
+ export {
246
+ FodFlowStore,
247
+ FodRuntime,
248
+ createFodServiceFacade,
249
+ createFodServiceFacadeForWorkspace,
250
+ endpointToNode,
251
+ executeFodFlow,
252
+ scanBackendFacade,
253
+ scanBackendFacadeToNodes
254
+ };
@@ -0,0 +1,17 @@
1
+ {
2
+ "$schema":"https://skipo.dev/schemas/kloks-manifest.v1.json",
3
+ "package":"@kloks/fod",
4
+ "version":"1.0.0",
5
+ "services":[
6
+ {
7
+ "id":"fod",
8
+ "name":"FOD Workflow Module",
9
+ "version":"1.0.0",
10
+ "description":"Embedded workflow discovery, persistence, validation and execution capability for Skipo applications.",
11
+ "backend":{"package":"@ultrst-armada/kloks","subpath":"fod","export":"FodServiceFacade","facade":"FodServiceFacade"},
12
+ "modes":["backend","fullstack"],
13
+ "targets":{"backend":["BackendFacade.services"],"frontend":["Main.tabs.fod"]},
14
+ "dependencies":[]
15
+ }
16
+ ]
17
+ }
@@ -0,0 +1,26 @@
1
+ {
2
+ "name": "@kloks/fod",
3
+ "version": "1.0.0",
4
+ "description": "Embedded FOD workflow orchestration module for Skipo applications.",
5
+ "type": "module",
6
+ "private": false,
7
+ "publishConfig": {"access":"public","registry":"https://registry.npmjs.org/"},
8
+ "main":"./dist/index.js","types":"./dist/index.d.ts","module":"./dist/index.js",
9
+ "exports": {".":{"import":"./dist/index.js","types":"./dist/index.d.ts","default":"./dist/index.js"}},
10
+ "scripts": {
11
+ "build":"tsup src/index.ts --format esm --dts --clean --external @ultrst-armada/krnl",
12
+ "typecheck":"tsc --noEmit",
13
+ "test":"vitest run",
14
+ "clean":"rm -rf dist"
15
+ },
16
+ "dependencies": {
17
+ "@kloks/backend":"workspace:*",
18
+ "@kloks/state-graph":"workspace:*"
19
+ },
20
+ "devDependencies": {
21
+ "@ultrst-armada/krnl":"^1.0.3",
22
+ "tsup":"^8.4.0",
23
+ "typescript":"^5.7.3",
24
+ "vitest":"^3.1.0"
25
+ }
26
+ }
@@ -16,20 +16,6 @@ import {
16
16
  useSkipoBind,
17
17
  useSkipoState
18
18
  } from "./chunk-EW4ACSZB.js";
19
- import {
20
- CommandApi,
21
- GhostStore,
22
- GraphStore
23
- } from "./chunk-4UVGXFEM.js";
24
- import {
25
- BaseGraph,
26
- BaseNode,
27
- BaseViewWindow,
28
- CustomGraph,
29
- CustomNode,
30
- CustomViewWindow,
31
- DEFAULT_GRAPH_SETTINGS
32
- } from "./chunk-KG6QYS26.js";
33
19
  import {
34
20
  AttractionEngine,
35
21
  GhostInferenceEngine,
@@ -45,6 +31,20 @@ import {
45
31
  WireTypeRegistry,
46
32
  initializeDefaultGraphRules
47
33
  } from "./chunk-TZOL3RN7.js";
34
+ import {
35
+ CommandApi,
36
+ GhostStore,
37
+ GraphStore
38
+ } from "./chunk-4UVGXFEM.js";
39
+ import {
40
+ BaseGraph,
41
+ BaseNode,
42
+ BaseViewWindow,
43
+ CustomGraph,
44
+ CustomNode,
45
+ CustomViewWindow,
46
+ DEFAULT_GRAPH_SETTINGS
47
+ } from "./chunk-KG6QYS26.js";
48
48
  import {
49
49
  AutoSolidify,
50
50
  SpatialEngine,