@bian-womp/spark-graph 0.1.8 → 0.1.9

package/lib/cjs/src/builder/Registry.d.ts

@@ -1,5 +1,14 @@
 import type { DataTypeDescriptor, NodeContext, NodeTypeDescriptor } from "../core/types";
 import type { NodeCategoryDescriptor } from "../core/categories";
+export interface ResolvedCoercionSync {
+    kind: "sync";
+    convert: (value: unknown) => unknown;
+}
+export interface ResolvedCoercionAsync {
+    kind: "async";
+    convertAsync: (value: unknown, signal: AbortSignal) => Promise<unknown>;
+}
+export type ResolvedCoercion = ResolvedCoercionSync | ResolvedCoercionAsync;
 export declare class CategoryRegistry {
     private categories;
     register<Impl, State>(cat: NodeCategoryDescriptor<Impl, State>): this;
@@ -24,6 +33,7 @@ export declare class Registry {
     }>;
     private coercions;
     private asyncCoercions;
+    private resolvedCache;
     registerType(desc: DataTypeDescriptor, opts?: {
         withArray?: boolean;
         arrayId?: string;
@@ -34,8 +44,12 @@ export declare class Registry {
         serialize: (value: unknown) => unknown;
         deserialize: (data: unknown) => unknown;
     }): this;
-    registerCoercion(fromTypeId: string, toTypeId: string, convert: (value: unknown) => unknown): this;
-    registerAsyncCoercion(fromTypeId: string, toTypeId: string, convertAsync: (value: unknown, signal: AbortSignal) => Promise<unknown>): this;
+    registerCoercion(fromTypeId: string, toTypeId: string, convert: (value: unknown) => unknown, opts?: {
+        nonTransitive?: boolean;
+    }): this;
+    registerAsyncCoercion(fromTypeId: string, toTypeId: string, convertAsync: (value: unknown, signal: AbortSignal) => Promise<unknown>, opts?: {
+        nonTransitive?: boolean;
+    }): this;
     canCoerce(fromTypeId: string | undefined, toTypeId: string | undefined): boolean;
     getCoercion(fromTypeId: string, toTypeId: string): ((value: unknown) => unknown) | undefined;
     getAsyncCoercion(fromTypeId: string, toTypeId: string): ((value: unknown, signal: AbortSignal) => Promise<unknown>) | undefined;
@@ -43,7 +57,9 @@ export declare class Registry {
         from: string;
         to: string;
         async: boolean;
+        nonTransitive: boolean;
     }>;
+    resolveCoercion(fromTypeId: string, toTypeId: string): ResolvedCoercion | undefined;
     registerEnum(desc: {
         id: string;
         displayName?: string;

package/lib/cjs/src/builder/Registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Registry.d.ts","sourceRoot":"","sources":["../../../../src/builder/Registry.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"Registry.d.ts","sourceRoot":"","sources":["../../../../src/builder/Registry.ts"],"names":[],"mappings":"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"}

package/lib/cjs/src/examples/shared.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../../../src/examples/shared.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAC/C,OAAO,KAAK,EAGV,eAAe,EAChB,MAAM,eAAe,CAAC;AAGvB,wBAAgB,uBAAuB,IAAI,QAAQ,CAoYlD;AAED,wBAAgB,wBAAwB,IAAI,eAAe,CAc1D;AAED,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,QAAQ,QA2BnD;AAqBD,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,QAAQ,QA6BvD;AAED,wBAAgB,aAAa,CAAC,QAAQ,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,6BAUrE"}
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../../../src/examples/shared.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAC/C,OAAO,KAAK,EAAoB,eAAe,EAAE,MAAM,eAAe,CAAC;AA2BvE,wBAAgB,uBAAuB,IAAI,QAAQ,CA+WlD;AAED,wBAAgB,wBAAwB,IAAI,eAAe,CA8B1D;AAED,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,QAAQ,QA2BnD;AAqBD,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,QAAQ,QA6BvD;AAED,wBAAgB,aAAa,CAAC,QAAQ,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,6BAUrE"}

package/lib/cjs/src/examples/simple.d.ts

@@ -1,4 +1,5 @@
-export declare function createSimpleGraphDef(): import("..").GraphDefinition;
+import { GraphDefinition } from "../core/types";
+export declare function createSimpleGraphDef(): GraphDefinition;
 export declare function createSimpleGraphRegistry(): import("..").Registry;
 export declare function main(): Promise<void>;
 //# sourceMappingURL=simple.d.ts.map

package/lib/cjs/src/examples/simple.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"simple.d.ts","sourceRoot":"","sources":["../../../../src/examples/simple.ts"],"names":[],"mappings":"AAOA,wBAAgB,oBAAoB,iCAEnC;AAED,wBAAgB,yBAAyB,0BAExC;AAGD,wBAAsB,IAAI,kBAqBzB"}
+{"version":3,"file":"simple.d.ts","sourceRoot":"","sources":["../../../../src/examples/simple.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,eAAe,CAAC;AAoChD,wBAAgB,oBAAoB,oBAEnC;AAED,wBAAgB,yBAAyB,0BAExC;AAGD,wBAAsB,IAAI,kBAsBzB"}

package/lib/esm/index.js

@@ -22,9 +22,12 @@ class Registry {
         this.serializers = new Map();
         this.coercions = new Map();
         this.asyncCoercions = new Map();
+        this.resolvedCache = new Map();
     }
     registerType(desc, opts) {
         this.types.set(desc.id, desc);
+        // Any structural change invalidates resolution cache
+        this.resolvedCache.clear();
         if (!this.serializers.has(desc.id)) {
             this.registerSerializer(desc.id, {
                 serialize: (v) => v,
@@ -81,46 +84,231 @@ class Registry {
         return this;
     }
     // Register a type coercion from one type id to another
-    registerCoercion(fromTypeId, toTypeId, convert) {
-        this.coercions.set(`${fromTypeId}->${toTypeId}`, convert);
+    registerCoercion(fromTypeId, toTypeId, convert, opts) {
+        this.coercions.set(`${fromTypeId}->${toTypeId}`, {
+            convert,
+            nonTransitive: !!opts?.nonTransitive,
+        });
+        // If both source and target have array variants, add derived array->array coercion
+        const fromArr = `${fromTypeId}[]`;
+        const toArr = `${toTypeId}[]`;
+        const arrKey = `${fromArr}->${toArr}`;
+        if (this.types.has(fromArr) && this.types.has(toArr)) {
+            if (!this.coercions.has(arrKey) && !this.asyncCoercions.has(arrKey)) {
+                this.coercions.set(arrKey, {
+                    convert: (value) => {
+                        if (Array.isArray(value))
+                            return value.map((v) => convert(v));
+                        // Best-effort: coerce single to array-of-single
+                        return [convert(value)];
+                    },
+                    nonTransitive: !!opts?.nonTransitive,
+                });
+            }
+        }
+        this.resolvedCache.clear();
         return this;
     }
     // Register an async type coercion from one type id to another
-    registerAsyncCoercion(fromTypeId, toTypeId, convertAsync) {
-        this.asyncCoercions.set(`${fromTypeId}->${toTypeId}`, convertAsync);
+    registerAsyncCoercion(fromTypeId, toTypeId, convertAsync, opts) {
+        this.asyncCoercions.set(`${fromTypeId}->${toTypeId}`, {
+            convertAsync,
+            nonTransitive: !!opts?.nonTransitive,
+        });
+        // If both source and target have array variants, add derived array->array async coercion
+        const fromArr = `${fromTypeId}[]`;
+        const toArr = `${toTypeId}[]`;
+        const arrKey = `${fromArr}->${toArr}`;
+        if (this.types.has(fromArr) && this.types.has(toArr)) {
+            if (!this.coercions.has(arrKey) && !this.asyncCoercions.has(arrKey)) {
+                this.asyncCoercions.set(arrKey, {
+                    convertAsync: async (value, signal) => {
+                        if (Array.isArray(value)) {
+                            const out = [];
+                            for (let i = 0; i < value.length; i++) {
+                                if (signal?.aborted)
+                                    throw signal.reason ?? new Error("aborted");
+                                // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+                                out.push(await convertAsync(value[i], signal));
+                            }
+                            return out;
+                        }
+                        return [await convertAsync(value, signal)];
+                    },
+                    nonTransitive: !!opts?.nonTransitive,
+                });
+            }
+        }
+        this.resolvedCache.clear();
         return this;
     }
     canCoerce(fromTypeId, toTypeId) {
         if (!fromTypeId || !toTypeId)
             return false;
-        if (fromTypeId === toTypeId)
-            return true;
-        const key = `${fromTypeId}->${toTypeId}`;
-        return this.coercions.has(key) || this.asyncCoercions.has(key);
+        return !!this.resolveCoercion(fromTypeId, toTypeId);
     }
     getCoercion(fromTypeId, toTypeId) {
-        if (fromTypeId === toTypeId)
-            return (v) => v;
-        return this.coercions.get(`${fromTypeId}->${toTypeId}`);
+        const resolved = this.resolveCoercion(fromTypeId, toTypeId);
+        if (!resolved)
+            return undefined;
+        if (resolved.kind === "sync")
+            return resolved.convert;
+        return undefined;
     }
     getAsyncCoercion(fromTypeId, toTypeId) {
-        if (fromTypeId === toTypeId)
+        const resolved = this.resolveCoercion(fromTypeId, toTypeId);
+        if (!resolved)
             return undefined;
-        return this.asyncCoercions.get(`${fromTypeId}->${toTypeId}`);
+        if (resolved.kind === "async")
+            return resolved.convertAsync;
+        return undefined;
     }
     // Introspection for dynamic discovery
     listCoercions() {
         const out = [];
-        for (const key of this.coercions.keys()) {
+        for (const [key, rec] of this.coercions.entries()) {
             const [from, to] = key.split("->");
-            out.push({ from, to, async: false });
+            out.push({
+                from,
+                to,
+                async: false,
+                nonTransitive: rec.nonTransitive,
+            });
         }
-        for (const key of this.asyncCoercions.keys()) {
+        for (const [key, rec] of this.asyncCoercions.entries()) {
             const [from, to] = key.split("->");
-            out.push({ from, to, async: true });
+            out.push({ from, to, async: true, nonTransitive: rec.nonTransitive });
         }
         return out;
     }
+    resolveCoercion(fromTypeId, toTypeId) {
+        const cacheKey = `${fromTypeId}->${toTypeId}`;
+        const cached = this.resolvedCache.get(cacheKey);
+        if (cached)
+            return cached;
+        if (fromTypeId === toTypeId) {
+            const res = { kind: "sync", convert: (v) => v };
+            this.resolvedCache.set(cacheKey, res);
+            return res;
+        }
+        // Direct edges (regardless of nonTransitive)
+        const directSync = this.coercions.get(cacheKey);
+        if (directSync) {
+            const res = {
+                kind: "sync",
+                convert: directSync.convert,
+            };
+            this.resolvedCache.set(cacheKey, res);
+            return res;
+        }
+        const directAsync = this.asyncCoercions.get(cacheKey);
+        if (directAsync) {
+            const res = {
+                kind: "async",
+                convertAsync: directAsync.convertAsync,
+            };
+            this.resolvedCache.set(cacheKey, res);
+            return res;
+        }
+        // Build adjacency from transitive-allowed edges only
+        const getNeighbors = (from) => {
+            const out = [];
+            for (const [key, rec] of this.coercions.entries()) {
+                if (rec.nonTransitive)
+                    continue;
+                const [src, dst] = key.split("->");
+                if (src === from)
+                    out.push({ from: src, to: dst, kind: "sync", convert: rec.convert });
+            }
+            for (const [key, rec] of this.asyncCoercions.entries()) {
+                if (rec.nonTransitive)
+                    continue;
+                const [src, dst] = key.split("->");
+                if (src === from)
+                    out.push({
+                        from: src,
+                        to: dst,
+                        kind: "async",
+                        convertAsync: rec.convertAsync,
+                    });
+            }
+            return out;
+        };
+        const betterOf = (a, b) => {
+            if (!a)
+                return true;
+            if (b.edges !== a.edges)
+                return b.edges < a.edges;
+            return b.async < a.async;
+        };
+        const best = new Map();
+        const queue = [];
+        const push = (e) => {
+            // simple insertion to keep queue roughly ordered by cost
+            let i = 0;
+            while (i < queue.length) {
+                const q = queue[i];
+                if (e.cost.edges < q.cost.edges ||
+                    (e.cost.edges === q.cost.edges && e.cost.async < q.cost.async)) {
+                    break;
+                }
+                i++;
+            }
+            queue.splice(i, 0, e);
+        };
+        push({ node: fromTypeId, cost: { edges: 0, async: 0 }, path: [] });
+        best.set(fromTypeId, { edges: 0, async: 0 });
+        while (queue.length > 0) {
+            const cur = queue.shift();
+            if (cur.node === toTypeId) {
+                // Compose
+                const hasAsync = cur.path.some((s) => s.kind === "async");
+                if (!hasAsync) {
+                    const convert = (value) => {
+                        let acc = value;
+                        for (const step of cur.path) {
+                            // all sync by construction
+                            acc = step.convert(acc);
+                        }
+                        return acc;
+                    };
+                    const res = { kind: "sync", convert };
+                    this.resolvedCache.set(cacheKey, res);
+                    return res;
+                }
+                else {
+                    const convertAsync = async (value, signal) => {
+                        let acc = value;
+                        for (const step of cur.path) {
+                            if (step.kind === "sync") {
+                                acc = step.convert(acc);
+                            }
+                            else {
+                                acc = await step.convertAsync(acc, signal);
+                            }
+                        }
+                        return acc;
+                    };
+                    const res = { kind: "async", convertAsync };
+                    this.resolvedCache.set(cacheKey, res);
+                    return res;
+                }
+            }
+            // expand neighbors
+            for (const step of getNeighbors(cur.node)) {
+                const nextCost = {
+                    edges: cur.cost.edges + 1,
+                    async: cur.cost.async + (step.kind === "async" ? 1 : 0),
+                };
+                const prev = best.get(step.to);
+                if (betterOf(prev, nextCost)) {
+                    best.set(step.to, nextCost);
+                    push({ node: step.to, cost: nextCost, path: [...cur.path, step] });
+                }
+            }
+        }
+        return undefined;
+    }
     // Enum support
     registerEnum(desc) {
         const { id, displayName, options, opts } = desc;
@@ -1329,79 +1517,89 @@ const CompositeCategory = (registry) => ({
     policy: { mode: "hybrid" },
 });
 
+// Helpers
+const asArray = (v) => Array.isArray(v) ? v : [Number(v)];
+const broadcast = (a, b) => {
+    const aa = asArray(a);
+    const bb = asArray(b);
+    if (aa.length === bb.length)
+        return [aa, bb];
+    if (aa.length === 1)
+        return [new Array(bb.length).fill(aa[0]), bb];
+    if (bb.length === 1)
+        return [aa, new Array(aa.length).fill(bb[0])];
+    const len = Math.max(aa.length, bb.length);
+    return [new Array(len).fill(aa[0] ?? 0), new Array(len).fill(bb[0] ?? 0)];
+};
+const clamp = (x, min, max) => Math.min(max, Math.max(min, x));
+const lerp = (a, b, t) => a + (b - a) * t;
+const lcg = (seed) => {
+    let s = seed >>> 0 || 1;
+    return () => (s = (s * 1664525 + 1013904223) >>> 0) / 0xffffffff;
+};
 function setupBasicGraphRegistry() {
     const registry = new Registry();
     registry.categories.register(ComputeCategory);
-    const floatType = {
+    registry.registerType({
         id: "base.float",
         validate: (v) => typeof v === "number" && !Number.isNaN(v),
-    };
-    registry.registerType(floatType);
-    registry.registerSerializer("base.float", {
-        serialize: (v) => v,
-        deserialize: (d) => Number(d),
-    });
-    const boolType = {
+    }, { withArray: true, arrayPickFirstDefined: true });
+    registry.registerType({
         id: "base.bool",
         validate: (v) => typeof v === "boolean",
-    };
-    const stringType = {
+    }, { withArray: true, arrayPickFirstDefined: true });
+    registry.registerType({
         id: "base.string",
         validate: (v) => typeof v === "string",
-    };
-    const vec3Type = {
+    }, { withArray: true, arrayPickFirstDefined: true });
+    registry.registerType({
         id: "base.vec3",
         validate: (v) => Array.isArray(v) &&
             v.length === 3 &&
             v.every((x) => typeof x === "number"),
-    };
-    [boolType, stringType, vec3Type, floatType].forEach((t) => {
-        registry.registerType(t, { withArray: true, arrayPickFirstDefined: true });
-        registry.registerSerializer(t.id, {
-            serialize: (v) => v,
-            deserialize: (d) => d,
-        });
+    }, { withArray: true, arrayPickFirstDefined: true });
+    // float -> vec3 : map x to [x,0,0]
+    registry.registerCoercion("base.float", "base.vec3", (v) => {
+        return [Number(v) || 0, 0, 0];
     });
-    // Helpers
-    const asArray = (v) => Array.isArray(v) ? v : [Number(v)];
-    // float[] -> vec3[] : map x to [x,0,0]
-    registry.registerCoercion("base.float[]", "base.vec3[]", (v) => {
-        const arr = asArray(v);
-        return arr.map((x) => [Number(x) || 0, 0, 0]);
+    // Async coercion variant for vec3 -> float (chunked + abortable)
+    registry.registerAsyncCoercion("base.vec3", "base.float", async (value, signal) => {
+        if (signal.aborted)
+            throw new DOMException("Aborted", "AbortError");
+        const v = value;
+        await new Promise((r) => setTimeout(r, 1000));
+        return Math.hypot(Number(v[0] ?? 0), Number(v[1] ?? 0), Number(v[2] ?? 0));
     });
-    // Async coercion variant for vec3[] -> float[] (chunked + abortable)
-    registry.registerAsyncCoercion("base.vec3[]", "base.float[]", async (value, signal) => {
-        const arr = Array.isArray(value)
-            ? value
-            : [];
-        const out = new Array(arr.length);
-        for (let i = 0; i < arr.length; i++) {
-            if (signal.aborted)
-                throw new DOMException("Aborted", "AbortError");
-            const v = arr[i] ?? [0, 0, 0];
-            await new Promise((r) => setTimeout(r, 1000));
-            out[i] = Math.hypot(Number(v[0] ?? 0), Number(v[1] ?? 0), Number(v[2] ?? 0));
-        }
-        return out;
+    registry.registerCoercion("base.bool", "base.float", (v) => (v ? 1 : 0));
+    registry.registerCoercion("base.float", "base.bool", (v) => !!v);
+    registry.registerCoercion("base.float", "base.string", (v) => String(v));
+    registry.registerCoercion("base.string", "base.float", (v) => Number(v));
+    // Enums: Math Operation
+    registry.registerEnum({
+        id: "base.enum:math.operation",
+        options: [
+            { value: 0, label: "Add" },
+            { value: 1, label: "Subtract" },
+            { value: 2, label: "Multiply" },
+            { value: 3, label: "Divide" },
+            { value: 4, label: "Min" },
+            { value: 5, label: "Max" },
+            { value: 6, label: "Modulo" },
+            { value: 7, label: "Power" },
+        ],
+    });
+    // Enums: Compare Operation
+    registry.registerEnum({
+        id: "base.enum:compare.operation",
+        options: [
+            { value: 0, label: "LessThan" },
+            { value: 1, label: "LessThanOrEqual" },
+            { value: 2, label: "GreaterThan" },
+            { value: 3, label: "GreaterThanOrEqual" },
+            { value: 4, label: "Equal" },
+            { value: 5, label: "NotEqual" },
+        ],
     });
-    const broadcast = (a, b) => {
-        const aa = asArray(a);
-        const bb = asArray(b);
-        if (aa.length === bb.length)
-            return [aa, bb];
-        if (aa.length === 1)
-            return [new Array(bb.length).fill(aa[0]), bb];
-        if (bb.length === 1)
-            return [aa, new Array(aa.length).fill(bb[0])];
-        const len = Math.max(aa.length, bb.length);
-        return [new Array(len).fill(aa[0] ?? 0), new Array(len).fill(bb[0] ?? 0)];
-    };
-    const clamp = (x, min, max) => Math.min(max, Math.max(min, x));
-    const lerp = (a, b, t) => a + (b - a) * t;
-    const lcg = (seed) => {
-        let s = seed >>> 0 || 1;
-        return () => (s = (s * 1664525 + 1013904223) >>> 0) / 0xffffffff;
-    };
     // Number
     registry.registerNode({
         id: "base.number",
@@ -1428,32 +1626,6 @@ function setupBasicGraphRegistry() {
         outputs: { Text: "base.string" },
         impl: (ins) => ({ Text: String(ins.Value) }),
     });
-    // Enums: Math Operation
-    registry.registerEnum({
-        id: "base.enum:math.operation",
-        options: [
-            { value: 0, label: "Add" },
-            { value: 1, label: "Subtract" },
-            { value: 2, label: "Multiply" },
-            { value: 3, label: "Divide" },
-            { value: 4, label: "Min" },
-            { value: 5, label: "Max" },
-            { value: 6, label: "Modulo" },
-            { value: 7, label: "Power" },
-        ],
-    });
-    // Enums: Compare Operation
-    registry.registerEnum({
-        id: "base.enum:compare.operation",
-        options: [
-            { value: 0, label: "LessThan" },
-            { value: 1, label: "LessThanOrEqual" },
-            { value: 2, label: "GreaterThan" },
-            { value: 3, label: "GreaterThanOrEqual" },
-            { value: 4, label: "Equal" },
-            { value: 5, label: "NotEqual" },
-        ],
-    });
     // Clamp
     registry.registerNode({
         id: "base.clamp",
@@ -1665,21 +1837,6 @@ function setupBasicGraphRegistry() {
     });
     return registry;
 }
-function makeBasicGraphDefinition() {
-    return {
-        nodes: [
-            { nodeId: "n1", typeId: "base.math" },
-            { nodeId: "n2", typeId: "base.math" },
-        ],
-        edges: [
-            {
-                id: "e1",
-                source: { nodeId: "n1", handle: "Result" },
-                target: { nodeId: "n2", handle: "A" },
-            },
-        ],
-    };
-}
 function registerDelayNode(registry) {
     registry.registerNode({
         id: "async.delay",
@@ -1753,6 +1910,37 @@ function registerProgressNodes(registry) {
     });
 }
 
+function makeBasicGraphDefinition() {
+    return {
+        nodes: [
+            { nodeId: "n1", typeId: "base.math" },
+            { nodeId: "n2", typeId: "base.math" },
+            // Transitivity demo nodes
+            { nodeId: "n3", typeId: "base.compare" },
+            { nodeId: "n4", typeId: "base.randomXYZs" },
+        ],
+        edges: [
+            {
+                id: "e1",
+                source: { nodeId: "n1", handle: "Result" },
+                target: { nodeId: "n2", handle: "A" },
+            },
+            // Feed n2 result to comparer A
+            {
+                id: "e2",
+                source: { nodeId: "n2", handle: "Result" },
+                target: { nodeId: "n3", handle: "A" },
+            },
+            // Transitive coercion edge: bool[] (n3.Result) -> vec3 (n4.Min)
+            // Path: bool[] -> float[] -> vec3[] -> vec3
+            {
+                id: "e3",
+                source: { nodeId: "n3", handle: "Result" },
+                target: { nodeId: "n4", handle: "Min" },
+            },
+        ],
+    };
+}
 function createSimpleGraphDef() {
     return makeBasicGraphDefinition();
 }